From d7915c40ea54b5bac7dbb6f38f7b61fa40f11eca Mon Sep 17 00:00:00 2001
From: Peter Van Gemmeren <peter.van.gemmeren@cern.ch>
Date: Wed, 13 Aug 2014 19:35:06 +0200
Subject: [PATCH] Attempt to fix memory leak when reading DataHeader Tokens
(PersistentDataModelTPCnv-00-02-03)
---
.../DataHeaderCnv_p3.h | 62 +++++
.../DataHeaderCnv_p4.h | 62 +++++
.../DataHeaderCnv_p5.h | 64 +++++
.../DataHeaderCnv_p6.h | 64 +++++
.../PersistentDataModelTPCnv/DataHeader_p3.h | 74 ++++++
.../PersistentDataModelTPCnv/DataHeader_p4.h | 74 ++++++
.../PersistentDataModelTPCnv/DataHeader_p5.h | 99 +++++++
.../PersistentDataModelTPCnv/DataHeader_p6.h | 131 ++++++++++
.../PersistentDataModelTPCnvDict.h | 25 ++
.../PersistentDataModelTPCnv/selection.xml | 32 +++
.../PersistentDataModelTPCnv/cmt/requirements | 18 ++
.../src/DataHeaderCnv_p3.cxx | 123 +++++++++
.../src/DataHeaderCnv_p4.cxx | 127 +++++++++
.../src/DataHeaderCnv_p5.cxx | 241 ++++++++++++++++++
.../src/DataHeaderCnv_p6.cxx | 111 ++++++++
.../src/DataHeader_p3.cxx | 106 ++++++++
.../src/DataHeader_p4.cxx | 105 ++++++++
.../src/DataHeader_p5.cxx | 143 +++++++++++
.../src/DataHeader_p6.cxx | 221 ++++++++++++++++
19 files changed, 1882 insertions(+)
create mode 100755 Database/PersistentDataModelTPCnv/PersistentDataModelTPCnv/DataHeaderCnv_p3.h
create mode 100755 Database/PersistentDataModelTPCnv/PersistentDataModelTPCnv/DataHeaderCnv_p4.h
create mode 100755 Database/PersistentDataModelTPCnv/PersistentDataModelTPCnv/DataHeaderCnv_p5.h
create mode 100755 Database/PersistentDataModelTPCnv/PersistentDataModelTPCnv/DataHeaderCnv_p6.h
create mode 100755 Database/PersistentDataModelTPCnv/PersistentDataModelTPCnv/DataHeader_p3.h
create mode 100755 Database/PersistentDataModelTPCnv/PersistentDataModelTPCnv/DataHeader_p4.h
create mode 100755 Database/PersistentDataModelTPCnv/PersistentDataModelTPCnv/DataHeader_p5.h
create mode 100755 Database/PersistentDataModelTPCnv/PersistentDataModelTPCnv/DataHeader_p6.h
create mode 100755 Database/PersistentDataModelTPCnv/PersistentDataModelTPCnv/PersistentDataModelTPCnvDict.h
create mode 100755 Database/PersistentDataModelTPCnv/PersistentDataModelTPCnv/selection.xml
create mode 100755 Database/PersistentDataModelTPCnv/cmt/requirements
create mode 100755 Database/PersistentDataModelTPCnv/src/DataHeaderCnv_p3.cxx
create mode 100755 Database/PersistentDataModelTPCnv/src/DataHeaderCnv_p4.cxx
create mode 100755 Database/PersistentDataModelTPCnv/src/DataHeaderCnv_p5.cxx
create mode 100755 Database/PersistentDataModelTPCnv/src/DataHeaderCnv_p6.cxx
create mode 100755 Database/PersistentDataModelTPCnv/src/DataHeader_p3.cxx
create mode 100755 Database/PersistentDataModelTPCnv/src/DataHeader_p4.cxx
create mode 100755 Database/PersistentDataModelTPCnv/src/DataHeader_p5.cxx
create mode 100755 Database/PersistentDataModelTPCnv/src/DataHeader_p6.cxx
diff --git a/Database/PersistentDataModelTPCnv/PersistentDataModelTPCnv/DataHeaderCnv_p3.h b/Database/PersistentDataModelTPCnv/PersistentDataModelTPCnv/DataHeaderCnv_p3.h
new file mode 100755
index 00000000000..da1a6767b92
--- /dev/null
+++ b/Database/PersistentDataModelTPCnv/PersistentDataModelTPCnv/DataHeaderCnv_p3.h
@@ -0,0 +1,62 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef PERSISTENTDATAMODELTPCNV_DATAHEADERCNV_P3_H
+#define PERSISTENTDATAMODELTPCNV_DATAHEADERCNV_P3_H
+
+/**
+ * @file DataHeaderCnv_p3.h
+ * @brief This file contains the class definition for the DataHeaderCnv_p3 and DataHeaderElementCnv_p3 classes.
+ * @author Peter van Gemmeren <gemmeren@anl.gov>
+ * $Id: DataHeaderCnv_p3.h,v 1.3 2009-04-21 21:48:34 gemmeren Exp $
+ **/
+
+#include "PersistentDataModel/DataHeader.h"
+#include "PersistentDataModelTPCnv/DataHeader_p3.h"
+
+/** @class DataHeaderElementCnv_p3
+ * @brief This class provides the converter to customize the saving of DataHeaderElement_p3.
+ **/
+class DataHeaderElementCnv_p3 {
+public:
+ DataHeaderElementCnv_p3();
+ virtual ~DataHeaderElementCnv_p3();
+
+ void persToTrans(const DataHeaderElement_p3* pers, DataHeaderElement* trans, const std::vector<std::string>& map);
+ void transToPers(const DataHeaderElement* trans, DataHeaderElement_p3* pers, std::vector<std::string>& map);
+
+friend class DataHeaderCnv_p3;
+};
+
+/** @class DataHeaderCnv_p3
+ * @brief This class provides the converter to customize the saving of DataHeader_p3.
+ **/
+class DataHeaderCnv_p3 {
+public:
+ DataHeaderCnv_p3();
+ virtual ~DataHeaderCnv_p3();
+
+ DataHeader* createTransient(const DataHeader_p3* persObj);
+ void persToTrans(const DataHeader_p3* pers, DataHeader* trans);
+ DataHeader_p3* createPersistent(const DataHeader* transObj);
+ void transToPers(const DataHeader* trans, DataHeader_p3* pers);
+
+ void insertDHRef(DataHeader_p3* pers, const std::string& key, const std::string& token);
+
+private:
+ DataHeaderElementCnv_p3 m_elemCnv;
+};
+
+inline DataHeader* DataHeaderCnv_p3::createTransient(const DataHeader_p3* persObj) {
+ DataHeader* trans = new DataHeader();
+ persToTrans(persObj, trans);
+ return(trans);
+}
+inline DataHeader_p3* DataHeaderCnv_p3::createPersistent(const DataHeader* transObj){
+ DataHeader_p3* pers = new DataHeader_p3();
+ transToPers(transObj, pers);
+ return(pers);
+}
+
+#endif
diff --git a/Database/PersistentDataModelTPCnv/PersistentDataModelTPCnv/DataHeaderCnv_p4.h b/Database/PersistentDataModelTPCnv/PersistentDataModelTPCnv/DataHeaderCnv_p4.h
new file mode 100755
index 00000000000..dec2f26f82f
--- /dev/null
+++ b/Database/PersistentDataModelTPCnv/PersistentDataModelTPCnv/DataHeaderCnv_p4.h
@@ -0,0 +1,62 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef PERSISTENTDATAMODELTPCNV_DATAHEADERCNV_P4_H
+#define PERSISTENTDATAMODELTPCNV_DATAHEADERCNV_P4_H
+
+/**
+ * @file DataHeaderCnv_p4.h
+ * @brief This file contains the class definition for the DataHeaderCnv_p4 and DataHeaderElementCnv_p4 classes.
+ * @author Peter van Gemmeren <gemmeren@anl.gov>
+ * $Id: DataHeaderCnv_p4.h,v 1.1 2009-04-21 21:48:34 gemmeren Exp $
+ **/
+
+#include "PersistentDataModel/DataHeader.h"
+#include "PersistentDataModelTPCnv/DataHeader_p4.h"
+
+/** @class DataHeaderElementCnv_p4
+ * @brief This class provides the converter to customize the saving of DataHeaderElement_p4.
+ **/
+class DataHeaderElementCnv_p4 {
+public:
+ DataHeaderElementCnv_p4();
+ virtual ~DataHeaderElementCnv_p4();
+
+ void persToTrans(const DataHeaderElement_p4* pers, DataHeaderElement* trans, const std::vector<std::string>& map);
+ void transToPers(const DataHeaderElement* trans, DataHeaderElement_p4* pers, std::vector<std::string>& map);
+
+friend class DataHeaderCnv_p4;
+};
+
+/** @class DataHeaderCnv_p4
+ * @brief This class provides the converter to customize the saving of DataHeader_p4.
+ **/
+class DataHeaderCnv_p4 {
+public:
+ DataHeaderCnv_p4();
+ virtual ~DataHeaderCnv_p4();
+
+ DataHeader* createTransient(const DataHeader_p4* persObj);
+ void persToTrans(const DataHeader_p4* pers, DataHeader* trans);
+ DataHeader_p4* createPersistent(const DataHeader* transObj);
+ void transToPers(const DataHeader* trans, DataHeader_p4* pers);
+
+ void insertDHRef(DataHeader_p4* pers, const std::string& key, const std::string& token);
+
+private:
+ DataHeaderElementCnv_p4 m_elemCnv;
+};
+
+inline DataHeader* DataHeaderCnv_p4::createTransient(const DataHeader_p4* persObj) {
+ DataHeader* trans = new DataHeader();
+ persToTrans(persObj, trans);
+ return(trans);
+}
+inline DataHeader_p4* DataHeaderCnv_p4::createPersistent(const DataHeader* transObj){
+ DataHeader_p4* pers = new DataHeader_p4();
+ transToPers(transObj, pers);
+ return(pers);
+}
+
+#endif
diff --git a/Database/PersistentDataModelTPCnv/PersistentDataModelTPCnv/DataHeaderCnv_p5.h b/Database/PersistentDataModelTPCnv/PersistentDataModelTPCnv/DataHeaderCnv_p5.h
new file mode 100755
index 00000000000..77a796a8e9e
--- /dev/null
+++ b/Database/PersistentDataModelTPCnv/PersistentDataModelTPCnv/DataHeaderCnv_p5.h
@@ -0,0 +1,64 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef PERSISTENTDATAMODELTPCNV_DATAHEADERCNV_P5_H
+#define PERSISTENTDATAMODELTPCNV_DATAHEADERCNV_P5_H
+
+/**
+ * @file DataHeaderCnv_p5.h
+ * @brief This file contains the class definition for the DataHeaderCnv_p5 and DataHeaderElementCnv_p5 classes.
+ * @author Peter van Gemmeren <gemmeren@anl.gov>
+ * $Id: DataHeaderCnv_p5.h,v 1.1 2009-04-21 21:48:34 gemmeren Exp $
+ **/
+
+#include "PersistentDataModel/DataHeader.h"
+#include "PersistentDataModelTPCnv/DataHeader_p5.h"
+
+#include <map>
+
+/** @class DataHeaderElementCnv_p5
+ * @brief This class provides the converter to customize the saving of DataHeaderElement_p5.
+ **/
+class DataHeaderElementCnv_p5 {
+public:
+ DataHeaderElementCnv_p5();
+ virtual ~DataHeaderElementCnv_p5();
+
+ void persToTrans(const DataHeaderElement_p5* pers, DataHeaderElement* trans, const DataHeaderForm_p5& form);
+ void transToPers(const DataHeaderElement* trans, DataHeaderElement_p5* pers, DataHeaderForm_p5& form);
+
+friend class DataHeaderCnv_p5;
+};
+
+/** @class DataHeaderCnv_p5
+ * @brief This class provides the converter to customize the saving of DataHeader_p5.
+ **/
+class DataHeaderCnv_p5 {
+public:
+ DataHeaderCnv_p5();
+ virtual ~DataHeaderCnv_p5();
+
+ DataHeader* createTransient(const DataHeader_p5* persObj);
+ void persToTrans(const DataHeader_p5* pers, DataHeader* trans);
+ DataHeader_p5* createPersistent(const DataHeader* transObj);
+ void transToPers(const DataHeader* trans, DataHeader_p5* pers);
+
+ void insertDHRef(DataHeader_p5* pers, const std::string& key, const std::string& strToken);
+
+private:
+ DataHeaderElementCnv_p5 m_elemCnv;
+};
+
+inline DataHeader* DataHeaderCnv_p5::createTransient(const DataHeader_p5* persObj) {
+ DataHeader* trans = new DataHeader();
+ persToTrans(persObj, trans);
+ return(trans);
+}
+inline DataHeader_p5* DataHeaderCnv_p5::createPersistent(const DataHeader* transObj){
+ DataHeader_p5* pers = new DataHeader_p5();
+ transToPers(transObj, pers);
+ return(pers);
+}
+
+#endif
diff --git a/Database/PersistentDataModelTPCnv/PersistentDataModelTPCnv/DataHeaderCnv_p6.h b/Database/PersistentDataModelTPCnv/PersistentDataModelTPCnv/DataHeaderCnv_p6.h
new file mode 100755
index 00000000000..573dfeac2a4
--- /dev/null
+++ b/Database/PersistentDataModelTPCnv/PersistentDataModelTPCnv/DataHeaderCnv_p6.h
@@ -0,0 +1,64 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef PERSISTENTDATAMODELTPCNV_DATAHEADERCNV_P6_H
+#define PERSISTENTDATAMODELTPCNV_DATAHEADERCNV_P6_H
+
+/**
+ * @file DataHeaderCnv_p6.h
+ * @brief This file contains the class definition for the DataHeaderCnv_p6 and DataHeaderElementCnv_p6 classes.
+ * @author Peter van Gemmeren <gemmeren@anl.gov>
+ * $Id: DataHeaderCnv_p6.h,v 1.1 2009-04-21 21:48:34 gemmeren Exp $
+ **/
+
+#include "PersistentDataModel/DataHeader.h"
+#include "PersistentDataModelTPCnv/DataHeader_p6.h"
+
+#include <map>
+
+/** @class DataHeaderElementCnv_p6
+ * @brief This class provides the converter to customize the saving of DataHeaderElement_p6.
+ **/
+class DataHeaderElementCnv_p6 {
+public:
+ DataHeaderElementCnv_p6();
+ virtual ~DataHeaderElementCnv_p6();
+
+ void persToTrans(const DataHeaderElement_p6* pers, DataHeaderElement* trans, const DataHeaderForm_p6& form);
+ void transToPers(const DataHeaderElement* trans, DataHeaderElement_p6* pers, DataHeaderForm_p6& form);
+
+friend class DataHeaderCnv_p6;
+};
+
+/** @class DataHeaderCnv_p6
+ * @brief This class provides the converter to customize the saving of DataHeader_p6.
+ **/
+class DataHeaderCnv_p6 {
+public:
+ DataHeaderCnv_p6();
+ virtual ~DataHeaderCnv_p6();
+
+ DataHeader* createTransient(const DataHeader_p6* persObj);
+ void persToTrans(const DataHeader_p6* pers, DataHeader* trans);
+ DataHeader_p6* createPersistent(const DataHeader* transObj);
+ void transToPers(const DataHeader* trans, DataHeader_p6* pers);
+
+ void insertDHRef(DataHeader_p6* pers, const std::string& key, const std::string& strToken);
+
+private:
+ DataHeaderElementCnv_p6 m_elemCnv;
+};
+
+inline DataHeader* DataHeaderCnv_p6::createTransient(const DataHeader_p6* persObj) {
+ DataHeader* trans = new DataHeader();
+ persToTrans(persObj, trans);
+ return(trans);
+}
+inline DataHeader_p6* DataHeaderCnv_p6::createPersistent(const DataHeader* transObj){
+ DataHeader_p6* pers = new DataHeader_p6();
+ transToPers(transObj, pers);
+ return(pers);
+}
+
+#endif
diff --git a/Database/PersistentDataModelTPCnv/PersistentDataModelTPCnv/DataHeader_p3.h b/Database/PersistentDataModelTPCnv/PersistentDataModelTPCnv/DataHeader_p3.h
new file mode 100755
index 00000000000..91dbfed275a
--- /dev/null
+++ b/Database/PersistentDataModelTPCnv/PersistentDataModelTPCnv/DataHeader_p3.h
@@ -0,0 +1,74 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef PERSISTENTDATAMODELTPCNV_DATAHEADER_P3_H
+#define PERSISTENTDATAMODELTPCNV_DATAHEADER_P3_H
+
+/** @file DataHeader_p3.h
+ * @brief This file contains the class definition for the DataHeader_p3 and DataHeaderElement_p3 classes.
+ * @author Peter van Gemmeren <gemmeren@anl.gov>
+ * $Id: DataHeader_p3.h,v 1.4 2009-04-08 19:13:19 gemmeren Exp $
+ **/
+
+#include <vector>
+#include <string>
+#include <stdint.h>
+
+/** @class DataHeaderElement_p3
+ * @brief This class provides a persistent representation for the DataHeaderElement class.
+ **/
+class DataHeaderElement_p3 {
+public: // Constructor and Destructor
+ DataHeaderElement_p3();
+ DataHeaderElement_p3(const DataHeaderElement_p3& rhs);
+ virtual ~DataHeaderElement_p3();
+
+ DataHeaderElement_p3& operator=(const DataHeaderElement_p3& rhs);
+
+friend class DataHeaderCnv_p3;
+friend class DataHeaderElementCnv_p3;
+
+ const std::string& key() const;
+ unsigned int pClid() const;
+ const std::vector<unsigned int>& clids() const;
+ const std::string& token() const;
+ const std::vector<std::string> alias() const;
+ unsigned int oid1() const;
+ unsigned int oid2() const;
+ void overwriteOid2(unsigned int oid2);
+
+private:
+ std::vector<unsigned int> m_clids;
+ std::string m_token;
+ std::vector<std::string> m_alias;
+ unsigned int m_technology, m_oid1, m_oid2;
+ unsigned short m_dbGuidIdx, m_classIdIdx, m_prefixIdx;
+ unsigned short m_keyPos;
+ std::vector<uint64_t> m_hashes;
+};
+
+/** @class DataHeader_p3
+ * @brief This class provides a persistent representation for the DataHeader class.
+ **/
+class DataHeader_p3 {
+public: // Constructor and Destructor
+ DataHeader_p3();
+ DataHeader_p3(const DataHeader_p3& rhs);
+ virtual ~DataHeader_p3();
+
+ DataHeader_p3& operator=(const DataHeader_p3& rhs);
+
+friend class DataHeaderCnv_p3;
+
+ const std::vector<DataHeaderElement_p3>& elements() const;
+ const std::vector<DataHeaderElement_p3>& inputElements() const;
+ const std::vector<std::string>& GuidMap() const;
+
+private:
+ std::vector<DataHeaderElement_p3> m_DataHeader;
+ std::vector<DataHeaderElement_p3> m_InputDataHeader;
+ std::vector<std::string> m_GuidMap;
+};
+
+#endif
diff --git a/Database/PersistentDataModelTPCnv/PersistentDataModelTPCnv/DataHeader_p4.h b/Database/PersistentDataModelTPCnv/PersistentDataModelTPCnv/DataHeader_p4.h
new file mode 100755
index 00000000000..01b30567ea7
--- /dev/null
+++ b/Database/PersistentDataModelTPCnv/PersistentDataModelTPCnv/DataHeader_p4.h
@@ -0,0 +1,74 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef PERSISTENTDATAMODELTPCNV_DATAHEADER_P4_H
+#define PERSISTENTDATAMODELTPCNV_DATAHEADER_P4_H
+
+/** @file DataHeader_p4.h
+ * @brief This file contains the class definition for the DataHeader_p4 and DataHeaderElement_p4 classes.
+ * @author Peter van Gemmeren <gemmeren@anl.gov>
+ * $Id: DataHeader_p4.h,v 1.1 2009-04-21 21:48:34 gemmeren Exp $
+ **/
+
+#include <vector>
+#include <string>
+#include <stdint.h>
+
+/** @class DataHeaderElement_p4
+ * @brief This class provides a persistent representation for the DataHeaderElement class.
+ **/
+class DataHeaderElement_p4 {
+public: // Constructor and Destructor
+ DataHeaderElement_p4();
+ DataHeaderElement_p4(const DataHeaderElement_p4& rhs);
+ virtual ~DataHeaderElement_p4();
+
+ DataHeaderElement_p4& operator=(const DataHeaderElement_p4& rhs);
+
+friend class DataHeaderCnv_p4;
+friend class DataHeaderElementCnv_p4;
+
+ unsigned int pClid() const;
+ const std::vector<unsigned int>& clids() const;
+ const std::string& key() const;
+ const std::vector<std::string>& alias() const;
+ const std::string& token() const;
+ unsigned int oid1() const;
+ unsigned int oid2() const;
+ void overwriteOid2(unsigned int oid2);
+
+private:
+ std::vector<unsigned int> m_clids;
+ std::string m_token;
+ std::vector<std::string> m_alias;
+ unsigned int m_technology, m_oid1, m_oid2;
+ unsigned short m_dbGuidIdx, m_classIdIdx, m_prefixIdx;
+ unsigned short m_keyPos;
+ std::vector<uint64_t> m_hashes;
+};
+
+/** @class DataHeader_p4
+ * @brief This class provides a persistent representation for the DataHeader class.
+ **/
+class DataHeader_p4 {
+public: // Constructor and Destructor
+ DataHeader_p4();
+ DataHeader_p4(const DataHeader_p4& rhs);
+ virtual ~DataHeader_p4();
+
+ DataHeader_p4& operator=(const DataHeader_p4& rhs);
+
+friend class DataHeaderCnv_p4;
+
+ const std::vector<DataHeaderElement_p4>& elements() const;
+ unsigned int provenanceSize() const;
+ const std::vector<std::string>& guidMap() const;
+
+private:
+ std::vector<DataHeaderElement_p4> m_dataHeader;
+ unsigned int m_provSize;
+ std::vector<std::string> m_guidMap;
+};
+
+#endif
diff --git a/Database/PersistentDataModelTPCnv/PersistentDataModelTPCnv/DataHeader_p5.h b/Database/PersistentDataModelTPCnv/PersistentDataModelTPCnv/DataHeader_p5.h
new file mode 100755
index 00000000000..79ef61e44c9
--- /dev/null
+++ b/Database/PersistentDataModelTPCnv/PersistentDataModelTPCnv/DataHeader_p5.h
@@ -0,0 +1,99 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef PERSISTENTDATAMODELTPCNV_DATAHEADER_P5_H
+#define PERSISTENTDATAMODELTPCNV_DATAHEADER_P5_H
+
+/** @file DataHeader_p5.h
+ * @brief This file contains the class definition for the DataHeader_p5,
+ * DataHeaderForm_p5 and DataHeaderElement_p5 classes.
+ * @author Peter van Gemmeren <gemmeren@anl.gov>
+ * $Id: DataHeader_p5.h,v 1.1 2009-04-21 21:48:34 gemmeren Exp $
+ **/
+
+#include <vector>
+#include <string>
+
+/** @class DataHeaderElement_p5
+ * @brief This class provides a persistent representation for the DataHeaderElement class.
+ **/
+class DataHeaderElement_p5 {
+public: // Constructor and Destructor
+ DataHeaderElement_p5();
+ DataHeaderElement_p5(const DataHeaderElement_p5& rhs);
+ virtual ~DataHeaderElement_p5();
+
+ DataHeaderElement_p5& operator=(const DataHeaderElement_p5& rhs);
+
+friend class DataHeaderCnv_p5;
+friend class DataHeaderElementCnv_p5;
+
+ const std::string& token() const;
+ unsigned int oid2() const;
+ void overwriteOid2(unsigned int oid2);
+
+private:
+ std::string m_token;
+ unsigned int m_oid2;
+};
+
+/** @class DataHeaderForm_p5
+ * @brief This class provides storage for the constant fields of the persistent DataHeader class.
+ **/
+class DataHeaderForm_p5 {
+public: // Constructor and Destructor
+ DataHeaderForm_p5();
+ DataHeaderForm_p5(const DataHeaderForm_p5& rhs);
+ virtual ~DataHeaderForm_p5();
+
+ DataHeaderForm_p5& operator=(const DataHeaderForm_p5& rhs);
+
+friend class DataHeaderCnv_p5;
+
+ const std::vector<std::string>& map() const;
+ void insertMap(const std::string& element);
+
+ const std::vector<unsigned int>& params() const;
+ void insertParam(unsigned int param);
+
+ unsigned int entry() const;
+ void start() const;
+ void next() const;
+ unsigned int size();
+ void resize(unsigned int size);
+
+private:
+ std::vector<std::string> m_map;
+ std::vector<std::vector<unsigned int> > m_uints;
+ mutable unsigned int m_entry;
+};
+
+/** @class DataHeader_p5
+ * @brief This class provides a persistent representation for the DataHeader class.
+ **/
+class DataHeader_p5 {
+public: // Constructor and Destructor
+ DataHeader_p5();
+ DataHeader_p5(const DataHeader_p5& rhs);
+ virtual ~DataHeader_p5();
+
+ DataHeader_p5& operator=(const DataHeader_p5& rhs);
+
+friend class DataHeaderCnv_p5;
+
+ const std::vector<DataHeaderElement_p5>& elements() const;
+ const DataHeaderForm_p5& dhForm() const;
+ void setDhForm(const DataHeaderForm_p5& form);
+ const std::string& dhFormToken() const;
+ void setDhFormToken(const std::string& formToken);
+ const std::string& dhFormMdx() const;
+
+private:
+ std::vector<DataHeaderElement_p5> m_dataHeader;
+ DataHeaderForm_p5 m_dhForm;
+ std::string m_dhFormToken;
+ std::string m_dhFormMdx;
+};
+
+#endif
diff --git a/Database/PersistentDataModelTPCnv/PersistentDataModelTPCnv/DataHeader_p6.h b/Database/PersistentDataModelTPCnv/PersistentDataModelTPCnv/DataHeader_p6.h
new file mode 100755
index 00000000000..93493969b48
--- /dev/null
+++ b/Database/PersistentDataModelTPCnv/PersistentDataModelTPCnv/DataHeader_p6.h
@@ -0,0 +1,131 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef PERSISTENTDATAMODELTPCNV_DATAHEADER_P6_H
+#define PERSISTENTDATAMODELTPCNV_DATAHEADER_P6_H
+
+/** @file DataHeader_p6.h
+ * @brief This file contains the class definition for the DataHeader_p6,
+ * DataHeaderForm_p6 and DataHeaderElement_p6 classes.
+ * @author Peter van Gemmeren <gemmeren@anl.gov>
+ * $Id: DataHeader_p6.h,v 1.1 2009-04-21 21:48:34 gemmeren Exp $
+ **/
+
+#include "PersistentDataModel/Guid.h"
+
+#include <vector>
+#include <set>
+#include <string>
+
+/** @class DataHeaderElement_p6
+ * @brief This class provides a persistent representation for the DataHeaderElement class.
+ **/
+class DataHeaderElement_p6 {
+public: // Constructor and Destructor
+ DataHeaderElement_p6();
+ DataHeaderElement_p6(const DataHeaderElement_p6& rhs);
+ virtual ~DataHeaderElement_p6();
+
+ DataHeaderElement_p6& operator=(const DataHeaderElement_p6& rhs);
+
+friend class DataHeaderCnv_p6;
+friend class DataHeaderElementCnv_p6;
+
+ const std::string& token() const;
+ unsigned long long oid1() const;
+ unsigned long long oid2() const;
+ void overwriteOid2(unsigned long long oid2);
+
+private:
+ std::string m_token;
+ unsigned long long m_oid1;
+ unsigned long long m_oid2;
+
+ unsigned int m_dbIdx; // entry with GUID & technology
+ unsigned int m_objIdx; // Will get entry with ClassId and transient CLID/key, direct clid for now...
+};
+
+/** @class DataHeaderForm_p6
+ * @brief This class provides storage for the constant fields of the persistent DataHeader class.
+ **/
+class DataHeaderForm_p6 {
+public:
+ typedef std::pair<Guid, unsigned int> DbRecord;
+ typedef std::pair<std::string, unsigned int> SgRecord;
+ typedef std::pair<Guid, SgRecord> ObjRecord;
+public: // Constructor and Destructor
+ DataHeaderForm_p6();
+ DataHeaderForm_p6(const DataHeaderForm_p6& rhs);
+ virtual ~DataHeaderForm_p6();
+
+ DataHeaderForm_p6& operator=(const DataHeaderForm_p6& rhs);
+
+friend class DataHeaderCnv_p6;
+
+ unsigned int insertDb(const DbRecord& rec);
+ std::size_t sizeDb() const;
+ Guid getDbGuid(unsigned int index) const;
+ unsigned int getDbTech(unsigned int index) const;
+
+ unsigned int insertObj(const ObjRecord& rec,
+ const std::set<std::string>& alias = std::set<std::string>(),
+ const std::set<unsigned int>& symLinks = std::set<unsigned int>(),
+ const std::vector<unsigned int>& hashes = std::vector<unsigned int>());
+ std::size_t sizeObj() const;
+ std::string getObjKey(unsigned int index) const;
+ unsigned int getObjType(unsigned int index) const;
+ Guid getObjClassId(unsigned int index) const;
+ std::set<std::string> getObjAlias(unsigned int index) const;
+ std::set<unsigned int> getObjSymLinks(unsigned int index) const;
+ std::vector<unsigned int> getObjHashes(unsigned int index) const;
+
+ const std::vector<unsigned int>& params() const;
+ void insertParam(unsigned int param);
+
+ unsigned int entry() const;
+ void start() const;
+ void next() const;
+ unsigned int size() const;
+ void resize(unsigned int size);
+
+private:
+ std::vector<std::vector<unsigned int> > m_uints;
+ std::vector<DbRecord> m_dbRecords;
+ std::vector<ObjRecord> m_objRecords;
+ std::vector<std::vector<std::string> > m_objAlias;
+ std::vector<std::vector<unsigned int> > m_objSymLinks;
+ std::vector<std::vector<unsigned int> > m_objHashes;
+ mutable unsigned int m_entry;
+};
+
+/** @class DataHeader_p6
+ * @brief This class provides a persistent representation for the DataHeader class.
+ **/
+class DataHeader_p6 {
+public: // Constructor and Destructor
+ DataHeader_p6();
+ DataHeader_p6(const DataHeader_p6& rhs);
+ virtual ~DataHeader_p6();
+
+ DataHeader_p6& operator=(const DataHeader_p6& rhs);
+
+friend class DataHeaderCnv_p6;
+
+ const std::vector<DataHeaderElement_p6>& elements() const;
+ const DataHeaderForm_p6& dhForm() const;
+ void setDhForm(const DataHeaderForm_p6& form);
+ const std::string& dhFormToken() const;
+ void setDhFormToken(const std::string& formToken);
+ void calculateDhFormMdx();
+ const std::string& dhFormMdx() const;
+
+private:
+ std::vector<DataHeaderElement_p6> m_dataHeader;
+ unsigned int m_provenanceSize;
+ DataHeaderForm_p6 m_dhForm;
+ std::string m_dhFormToken;
+ std::string m_dhFormMdx;
+};
+
+#endif
diff --git a/Database/PersistentDataModelTPCnv/PersistentDataModelTPCnv/PersistentDataModelTPCnvDict.h b/Database/PersistentDataModelTPCnv/PersistentDataModelTPCnv/PersistentDataModelTPCnvDict.h
new file mode 100755
index 00000000000..a400a019cfa
--- /dev/null
+++ b/Database/PersistentDataModelTPCnv/PersistentDataModelTPCnv/PersistentDataModelTPCnvDict.h
@@ -0,0 +1,25 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef PERSISTENTDATAMODEL_PERSISTENTDATAMODELTPCNVDICT_H
+#define PERSISTENTDATAMODEL_PERSISTENTDATAMODELTPCNVDICT_H
+
+#include "PersistentDataModelTPCnv/DataHeader_p3.h"
+#include "PersistentDataModelTPCnv/DataHeader_p4.h"
+#include "PersistentDataModelTPCnv/DataHeader_p5.h"
+#include "PersistentDataModelTPCnv/DataHeader_p6.h"
+#include "PersistentDataModelTPCnv/DataHeaderCnv_p5.h"
+#include "PersistentDataModelTPCnv/DataHeaderCnv_p6.h"
+
+// Need to instantiate iterators
+namespace PersistentDataModelTPCnvDict {
+ // template instantiations
+ std::pair<Guid, unsigned int> dummy_dbRecord;
+ std::vector<std::pair<Guid, unsigned int> > dummy_dbRecords;
+ std::pair<std::string, unsigned int> dummy_sgRecord;
+ std::pair<Guid, std::pair<std::string, unsigned int> > dummy_objRecord;
+ std::vector<std::pair<Guid, std::pair<std::string, unsigned int> > >dummy_objRecords;
+}
+
+#endif
diff --git a/Database/PersistentDataModelTPCnv/PersistentDataModelTPCnv/selection.xml b/Database/PersistentDataModelTPCnv/PersistentDataModelTPCnv/selection.xml
new file mode 100755
index 00000000000..a393fad05ac
--- /dev/null
+++ b/Database/PersistentDataModelTPCnv/PersistentDataModelTPCnv/selection.xml
@@ -0,0 +1,32 @@
+<lcgdict>
+ <class name="DataHeader_p3" id="EC1318F0-8E28-45F8-9A2D-2597C1CC87A6" />
+ <class name="std::vector<DataHeaderElement_p3>" />
+ <class name="DataHeaderElement_p3" />
+ <class name="DataHeader_p4" id="9630EB7B-CCD7-47D9-A39B-CBBF4133CDF2" />
+ <class name="std::vector<DataHeaderElement_p4>" />
+ <class name="DataHeaderElement_p4" />
+ <class name="DataHeader_p5" id="D82968A1-CF91-4320-B2DD-E0F739CBC7E6">
+ <field name="m_dhForm" transient="true" />
+ </class>
+ <class name="std::vector<DataHeaderElement_p5>" />
+ <class name="DataHeaderElement_p5" />
+ <class name="DataHeaderForm_p5" id="3397D8A3-BBE6-463C-9F8E-4B3DFD8831FE">
+ <field name="m_entry" transient="true" />
+ </class>
+ <class name="DataHeaderCnv_p5"/>
+ <class name="DataHeader_p6" id="4DDBD295-EFCE-472A-9EC8-15CD35A9EB8D">
+ <field name="m_dhForm" transient="true" />
+ </class>
+ <class name="std::vector<DataHeaderElement_p6>" />
+ <class name="DataHeaderElement_p6" />
+ <class name="DataHeaderForm_p6" id="7BE56CEF-C866-4BEE-9348-A5F34B5F1DAD">
+ <field name="m_entry" transient="true" />
+ </class>
+ <class name="std::vector<std::pair<Guid, unsigned int> >" />
+ <class name="std::pair<Guid, unsigned int>" />
+ <class name="Guid" />
+ <class name="std::vector<std::pair<Guid, std::pair<std::string, unsigned int> > >" />
+ <class name="std::pair<Guid, std::pair<std::string, unsigned int> >" />
+ <class name="std::pair<std::string, unsigned int>" />
+ <class name="DataHeaderCnv_p6"/>
+</lcgdict>
diff --git a/Database/PersistentDataModelTPCnv/cmt/requirements b/Database/PersistentDataModelTPCnv/cmt/requirements
new file mode 100755
index 00000000000..42b9cb5e702
--- /dev/null
+++ b/Database/PersistentDataModelTPCnv/cmt/requirements
@@ -0,0 +1,18 @@
+package PersistentDataModelTPCnv
+
+author Peter van Gemmeren <gemmeren@anl.gov>
+
+use AtlasPolicy AtlasPolicy-*
+
+use PersistentDataModel PersistentDataModel-* Database
+
+library PersistentDataModelTPCnv *.cxx
+apply_pattern installed_library
+
+private
+use AtlasReflex AtlasReflex-* External -no_auto_imports
+use uuid * LCG_Interfaces
+
+use CxxUtils CxxUtils-* Control
+
+apply_pattern lcgdict dict=PersistentDataModelTPCnv selectionfile=selection.xml headerfiles="-s=${PersistentDataModelTPCnv_root}/PersistentDataModelTPCnv PersistentDataModelTPCnvDict.h"
diff --git a/Database/PersistentDataModelTPCnv/src/DataHeaderCnv_p3.cxx b/Database/PersistentDataModelTPCnv/src/DataHeaderCnv_p3.cxx
new file mode 100755
index 00000000000..278b724f40c
--- /dev/null
+++ b/Database/PersistentDataModelTPCnv/src/DataHeaderCnv_p3.cxx
@@ -0,0 +1,123 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+/** @file DataHeaderCnv_p3.cxx
+ * @brief This file contains the implementation for the DataHeaderCnv_p3 class.
+ * @author Peter van Gemmeren <gemmeren@anl.gov>
+ * $Id: DataHeaderCnv_p3.cxx,v 1.6 2009-05-15 01:01:57 gemmeren Exp $
+ **/
+
+#define private public
+#define protected public
+#include "PersistentDataModel/DataHeader.h"
+#undef private
+#undef protected
+
+#include "PersistentDataModelTPCnv/DataHeaderCnv_p3.h"
+
+#include <cstdio>
+#include <sstream>
+
+DataHeaderElementCnv_p3::DataHeaderElementCnv_p3() {}
+DataHeaderElementCnv_p3::~DataHeaderElementCnv_p3() {}
+
+//______________________________________________________________________________
+void DataHeaderElementCnv_p3::persToTrans(const DataHeaderElement_p3* pers,
+ DataHeaderElement* trans,
+ const std::vector<std::string>& map) {
+ trans->m_pClid = *pers->m_clids.begin();
+ trans->m_clids.clear();
+ std::set<CLID>::iterator lastClid = trans->m_clids.begin();
+ for (std::vector<unsigned int>::const_iterator iter = pers->m_clids.begin() + 1,
+ last = pers->m_clids.end(); iter != last; iter++) {
+ lastClid = trans->m_clids.insert(lastClid, *iter);
+ }
+ trans->m_key = *pers->m_alias.begin();
+ trans->m_alias.clear();
+ std::set<std::string>::iterator lastAlias = trans->m_alias.begin();
+ for (std::vector<std::string>::const_iterator iter = pers->m_alias.begin() + 1,
+ last = pers->m_alias.end(); iter != last; iter++) {
+ lastAlias = trans->m_alias.insert(lastAlias, *iter);
+ }
+ trans->m_hashes.clear();
+ trans->m_hashes.reserve(pers->m_hashes.size());
+ for (std::vector<uint64_t>::const_iterator iter = pers->m_hashes.begin(),
+ last = pers->m_hashes.end(); iter != last; iter++) {
+ trans->m_hashes.push_back((unsigned int)(*iter));
+ }
+// Translate PoolToken
+ std::string tokenStr;
+ if (map.empty()) {
+ tokenStr = pers->m_token;
+ } else {
+ unsigned int tokenSize = 129 + pers->m_token.size();
+ if (pers->m_prefixIdx > 0) {
+ tokenSize += map[pers->m_prefixIdx].size();
+ }
+ if (pers->m_keyPos > 0) {
+ tokenSize += trans->m_key.size();
+ }
+ tokenStr.reserve(tokenSize);
+// Append DbGuid
+ tokenStr = "[DB=";
+ tokenStr.append(map[pers->m_dbGuidIdx]);
+// Still optimize
+ tokenStr.append("][CNT=");
+ if (pers->m_prefixIdx > 0) {
+ tokenStr.append(map[pers->m_prefixIdx]);
+ }
+// insert key
+ if (pers->m_keyPos > 0) {
+ tokenStr.append(pers->m_token.substr(0, pers->m_keyPos - 1));
+ tokenStr.append(trans->m_key);
+ tokenStr.append(pers->m_token.substr(pers->m_keyPos - 1));
+ } else {
+ tokenStr.append(pers->m_token);
+ }
+// Append ClassId
+ tokenStr.append("][CLID=");
+ tokenStr.append(map[pers->m_classIdIdx]);
+ const unsigned int length = 40;
+ char text[length];
+ snprintf(text, length, "][TECH=%08X][OID=%08X-%08X]", pers->m_technology, pers->m_oid1, pers->m_oid2);
+ tokenStr.append(text);
+ }
+ delete trans->m_token; trans->m_token = new Token;
+ const_cast<Token*>(trans->m_token)->fromString(tokenStr);
+}
+//______________________________________________________________________________
+void DataHeaderElementCnv_p3::transToPers(const DataHeaderElement* /*trans*/,
+ DataHeaderElement_p3* /*pers*/,
+ std::vector<std::string>& /*map*/) {
+// Moved to next _p version
+}
+//______________________________________________________________________________
+//______________________________________________________________________________
+DataHeaderCnv_p3::DataHeaderCnv_p3() {}
+DataHeaderCnv_p3::~DataHeaderCnv_p3() {}
+//______________________________________________________________________________
+void DataHeaderCnv_p3::persToTrans(const DataHeader_p3* pers, DataHeader* trans) {
+ trans->m_dataHeader.resize(pers->m_DataHeader.size());
+ std::vector<DataHeaderElement>::iterator it = trans->m_dataHeader.begin();
+ for (std::vector<DataHeaderElement_p3>::const_iterator pit = pers->m_DataHeader.begin(),
+ last = pers->m_DataHeader.end(); pit != last; it++, pit++) {
+ m_elemCnv.persToTrans(&(*pit), &(*it), pers->m_GuidMap);
+ }
+ trans->m_inputDataHeader.resize(pers->m_InputDataHeader.size());
+ it = trans->m_inputDataHeader.begin();
+ for (std::vector<DataHeaderElement_p3>::const_iterator pit = pers->m_InputDataHeader.begin(),
+ last = pers->m_InputDataHeader.end(); pit != last; it++, pit++) {
+ m_elemCnv.persToTrans(&(*pit), &(*it), pers->m_GuidMap);
+ }
+}
+//______________________________________________________________________________
+void DataHeaderCnv_p3::transToPers(const DataHeader* /*trans*/, DataHeader_p3* /*pers*/) {
+// Moved to next _p version
+}
+//______________________________________________________________________________
+void DataHeaderCnv_p3::insertDHRef(DataHeader_p3* /*pers*/,
+ const std::string& /*key*/,
+ const std::string& /*token*/) {
+// Moved to next _p version
+}
diff --git a/Database/PersistentDataModelTPCnv/src/DataHeaderCnv_p4.cxx b/Database/PersistentDataModelTPCnv/src/DataHeaderCnv_p4.cxx
new file mode 100755
index 00000000000..c8e373d113b
--- /dev/null
+++ b/Database/PersistentDataModelTPCnv/src/DataHeaderCnv_p4.cxx
@@ -0,0 +1,127 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+/** @file DataHeaderCnv_p4.cxx
+ * @brief This file contains the implementation for the DataHeaderCnv_p4 class.
+ * @author Peter van Gemmeren <gemmeren@anl.gov>
+ * $Id: DataHeaderCnv_p4.cxx,v 1.3 2009-05-15 01:01:57 gemmeren Exp $
+ **/
+
+#define private public
+#define protected public
+#include "PersistentDataModel/DataHeader.h"
+#undef private
+#undef protected
+
+#include "PersistentDataModelTPCnv/DataHeaderCnv_p4.h"
+
+#include <cstdio>
+#include <sstream>
+
+DataHeaderElementCnv_p4::DataHeaderElementCnv_p4() {}
+DataHeaderElementCnv_p4::~DataHeaderElementCnv_p4() {}
+
+//______________________________________________________________________________
+void DataHeaderElementCnv_p4::persToTrans(const DataHeaderElement_p4* pers,
+ DataHeaderElement* trans,
+ const std::vector<std::string>& map) {
+ std::vector<unsigned int>::const_iterator intIter = pers->m_clids.begin();
+ const std::vector<unsigned int>::const_iterator intLast = pers->m_clids.end();
+ trans->m_pClid = *intIter; intIter++;
+ trans->m_clids.clear();
+ for (std::set<CLID>::const_iterator lastClid = trans->m_clids.begin();
+ intIter != intLast; intIter++) {
+ lastClid = trans->m_clids.insert(lastClid, *intIter);
+ }
+ std::vector<std::string>::const_iterator strIter = pers->m_alias.begin();
+ const std::vector<std::string>::const_iterator strLast = pers->m_alias.end();
+ trans->m_key = *strIter; strIter++;
+ trans->m_alias.clear();
+ for (std::set<std::string>::const_iterator lastAlias = trans->m_alias.begin();
+ strIter != strLast; strIter++) {
+ lastAlias = trans->m_alias.insert(lastAlias, *strIter);
+ }
+ trans->m_hashes.clear();
+ trans->m_hashes.reserve(pers->m_hashes.size());
+ for (std::vector<uint64_t>::const_iterator iter = pers->m_hashes.begin(),
+ last = pers->m_hashes.end(); iter != last; iter++) {
+ trans->m_hashes.push_back((unsigned int)(*iter));
+ }
+// Translate PoolToken
+ std::string tokenStr;
+ if (map.empty()) {
+ tokenStr = pers->m_token;
+ } else {
+ unsigned int tokenSize = 129 + pers->m_token.size();
+ if (pers->m_prefixIdx > 0) {
+ tokenSize += map[pers->m_prefixIdx].size();
+ }
+ if (pers->m_keyPos > 0) {
+ tokenSize += trans->m_key.size();
+ }
+ tokenStr.reserve(tokenSize);
+// Append DbGuid
+ tokenStr = "[DB=";
+ tokenStr.append(map[pers->m_dbGuidIdx]);
+// Still optimize
+ tokenStr.append("][CNT=");
+ std::string cntName;
+ if (pers->m_prefixIdx > 0) {
+ tokenStr.append(map[pers->m_prefixIdx]);
+ }
+// insert key
+ if (pers->m_keyPos > 0) {
+ tokenStr.append(pers->m_token.substr(0, pers->m_keyPos - 1));
+ tokenStr.append(trans->m_key);
+ tokenStr.append(pers->m_token.substr(pers->m_keyPos - 1));
+ } else {
+ tokenStr.append(pers->m_token);
+ }
+// Append ClassId
+ tokenStr.append("][CLID=");
+ tokenStr.append(map[pers->m_classIdIdx]);
+// Add Technology and Offsets
+ const unsigned int length = 40;
+ char text[length];
+ snprintf(text, length, "][TECH=%08X][OID=%08X-%08X]", pers->m_technology, pers->m_oid1, pers->m_oid2);
+ tokenStr.append(text);
+ }
+ delete trans->m_token; trans->m_token = new Token;
+ const_cast<Token*>(trans->m_token)->fromString(tokenStr);
+}
+//______________________________________________________________________________
+void DataHeaderElementCnv_p4::transToPers(const DataHeaderElement* /*trans*/,
+ DataHeaderElement_p4* /*pers*/,
+ std::vector<std::string>& /*map*/) {
+// Moved to next _p version
+}
+//______________________________________________________________________________
+//______________________________________________________________________________
+DataHeaderCnv_p4::DataHeaderCnv_p4() {}
+DataHeaderCnv_p4::~DataHeaderCnv_p4() {}
+//______________________________________________________________________________
+void DataHeaderCnv_p4::persToTrans(const DataHeader_p4* pers, DataHeader* trans) {
+ trans->m_inputDataHeader.resize(pers->m_provSize);
+ std::vector<DataHeaderElement>::iterator it = trans->m_inputDataHeader.begin();
+ std::vector<DataHeaderElement_p4>::const_iterator pit = pers->m_dataHeader.begin();
+ for (unsigned int i = 0U; i != pers->m_provSize; i++, it++, pit++) {
+ m_elemCnv.persToTrans(&(*pit), &(*it), pers->m_guidMap);
+ }
+ trans->m_dataHeader.resize(pers->m_dataHeader.size() - pers->m_provSize);
+ it = trans->m_dataHeader.begin();
+ for (std::vector<DataHeaderElement_p4>::const_iterator last = pers->m_dataHeader.end();
+ pit != last; it++, pit++) {
+ m_elemCnv.persToTrans(&(*pit), &(*it), pers->m_guidMap);
+ }
+}
+//______________________________________________________________________________
+void DataHeaderCnv_p4::transToPers(const DataHeader* /*trans*/, DataHeader_p4* /*pers*/) {
+// Moved to next _p version
+}
+//______________________________________________________________________________
+void DataHeaderCnv_p4::insertDHRef(DataHeader_p4* /*pers*/,
+ const std::string& /*key*/,
+ const std::string& /*token*/) {
+// Moved to next _p version
+}
diff --git a/Database/PersistentDataModelTPCnv/src/DataHeaderCnv_p5.cxx b/Database/PersistentDataModelTPCnv/src/DataHeaderCnv_p5.cxx
new file mode 100755
index 00000000000..9cad285a1fb
--- /dev/null
+++ b/Database/PersistentDataModelTPCnv/src/DataHeaderCnv_p5.cxx
@@ -0,0 +1,241 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+/** @file DataHeaderCnv_p5.cxx
+ * @brief This file contains the implementation for the DataHeaderCnv_p5 class.
+ * @author Peter van Gemmeren <gemmeren@anl.gov>
+ * $Id: DataHeaderCnv_p5.cxx,v 1.3.2.2 2009-05-22 19:26:54 gemmeren Exp $
+ **/
+
+#define private public
+#define protected public
+#include "PersistentDataModel/DataHeader.h"
+#undef private
+#undef protected
+
+#include "PersistentDataModelTPCnv/DataHeaderCnv_p5.h"
+
+DataHeaderElementCnv_p5::DataHeaderElementCnv_p5() {}
+DataHeaderElementCnv_p5::~DataHeaderElementCnv_p5() {}
+
+//______________________________________________________________________________
+void DataHeaderElementCnv_p5::persToTrans(const DataHeaderElement_p5* pers,
+ DataHeaderElement* trans,
+ const DataHeaderForm_p5& form) {
+ delete trans->m_token; trans->m_token = new Token; trans->m_ownToken = true;
+ Token* token = const_cast<Token*>(trans->m_token);
+ std::vector<unsigned int>::const_iterator intIter = form.params().begin();
+ unsigned int keyIdx = 0U, aliasNum = 0U, clidNum = 0U;
+// Translate PoolToken
+ if ((*intIter&0x0000FFFF) == 0) {
+ intIter++;
+ keyIdx = *intIter; intIter++;
+ aliasNum = *intIter; intIter++;
+ clidNum = *intIter; intIter++;
+ token->fromString(pers->m_token);
+ } else {
+ const unsigned int keyPos = (unsigned short)(*intIter>>16); intIter++;
+ const unsigned int guidIdx = (unsigned short)(*intIter>>16),
+ classIdx = (unsigned short)(*intIter&0x0000FFFF); intIter++;
+ const unsigned int prefixIdx = (unsigned short)(*intIter>>16),
+ typeIdx = (unsigned short)(*intIter&0x0000FFFF); intIter++;
+// Add Technology and Offsets
+ unsigned int tech = *intIter; intIter++;
+ unsigned int oid1 = *intIter; intIter++;
+ keyIdx = *intIter; intIter++;
+ aliasNum = *intIter; intIter++;
+ clidNum = *intIter; intIter++;
+// Append DbGuid
+ Guid guid(form.map()[guidIdx]);
+ token->setDb(guid);
+// Container name, may be optimized
+ std::string cntName;
+ if (prefixIdx > 0) {
+ cntName += form.map()[prefixIdx];
+ if (typeIdx > 0) {
+ cntName += form.map()[typeIdx];
+ }
+ }
+// Insert key
+ if (keyPos > 0) {
+ cntName += pers->m_token.substr(0, keyPos - 1) + form.map()[keyIdx] + pers->m_token.substr(keyPos - 1);
+ } else {
+ cntName += pers->m_token;
+ }
+ //token->setCont(cntName);
+// Append ClassId
+ Guid clid(form.map()[classIdx]);
+ token->setClassID(clid);
+ token->setTechnology(tech);
+ token->setOid(Token::OID_t(oid1, pers->m_oid2));
+ }
+ unsigned int aliasCur = 0U, clidCur = 0U;
+ trans->m_key = form.map()[keyIdx];
+ trans->m_alias.clear();
+ for (std::set<std::string>::const_iterator lastAlias = trans->m_alias.begin();
+ aliasCur < aliasNum; aliasCur++) {
+ lastAlias = trans->m_alias.insert(lastAlias, form.map()[keyIdx + aliasCur + 1]);
+ }
+ trans->m_pClid = *intIter; intIter++;
+ trans->m_clids.clear();
+ const std::vector<unsigned int>::const_iterator intLast = form.params().end();
+ for (std::set<CLID>::const_iterator lastClid = trans->m_clids.begin();
+ intIter != intLast && clidCur < clidNum; intIter++, clidCur++) {
+ lastClid = trans->m_clids.insert(lastClid, *intIter);
+ }
+ trans->m_hashes.clear();
+ for (; intIter != intLast; intIter++) {
+ trans->m_hashes.push_back(*intIter);
+ }
+}
+//______________________________________________________________________________
+void DataHeaderElementCnv_p5::transToPers(const DataHeaderElement* trans,
+ DataHeaderElement_p5* pers,
+ DataHeaderForm_p5& form) {
+ unsigned int tech = 0U, oid1 = 0U;
+ unsigned short guidIdx = 0U, classIdx = 0U, prefixIdx = 0U, typeIdx = 0U, keyPos = 0U;
+// Translate PoolToken
+ if (trans->getToken() != 0) {
+// Database GUID
+ const std::string guid = trans->getToken()->dbID().toString();
+ for (std::vector<std::string>::const_iterator iter = form.map().begin(), last = form.map().end();
+ iter != last; iter++, guidIdx++) {
+ if (*iter == guid) break;
+ }
+ if (guidIdx == form.map().size()) {
+ form.insertMap(guid);
+ }
+// Class GUID
+ const std::string clid = trans->getToken()->classID().toString();
+ for (std::vector<std::string>::const_iterator iter = form.map().begin(), last = form.map().end();
+ iter != last; iter++, classIdx++) {
+ if (*iter == clid) break;
+ }
+ if (classIdx == form.map().size()) {
+ form.insertMap(clid);
+ }
+// Container name, can be optimized
+ pers->m_token = trans->getToken()->contID();
+// Get Prefix
+ std::string::size_type delim = pers->m_token.find_first_of("_/(");
+ if (delim != std::string::npos) {
+ const std::string persComp1 = pers->m_token.substr(0, delim + 1);
+ for (std::vector<std::string>::const_iterator iter = form.map().begin(), last = form.map().end();
+ iter != last; iter++, prefixIdx++) {
+ if (*iter == persComp1) break;
+ }
+ if (prefixIdx == form.map().size()) {
+ form.insertMap(persComp1);
+ }
+ pers->m_token = pers->m_token.substr(delim + 1);
+// Get TypeName
+ std::string::size_type delim = pers->m_token.find_first_of("/()");
+ if (delim != std::string::npos) {
+ const std::string persComp2 = pers->m_token.substr(0, delim + 1);
+ for (std::vector<std::string>::const_iterator iter = form.map().begin(), last = form.map().end();
+ iter != last; iter++, typeIdx++) {
+ if (*iter == persComp2) break;
+ }
+ if (typeIdx == form.map().size()) {
+ form.insertMap(persComp2);
+ }
+ pers->m_token = pers->m_token.substr(delim + 1);
+ } else if (pers->m_token == "DataHeader") {
+ for (std::vector<std::string>::const_iterator iter = form.map().begin(), last = form.map().end();
+ iter != last; iter++, typeIdx++) {
+ if (*iter == "DataHeader") break;
+ }
+ if (typeIdx == form.map().size()) {
+ form.insertMap("DataHeader");
+ }
+ pers->m_token.clear();
+ }
+ }
+ delim = pers->m_token.rfind(trans->m_key);
+ if (delim != std::string::npos) {
+ keyPos = delim + 1;
+ pers->m_token = pers->m_token.substr(0, delim) + pers->m_token.substr(delim + trans->m_key.size());
+ }
+ tech = trans->getToken()->technology();
+ oid1 = trans->getToken()->oid().first;
+ pers->m_oid2 = trans->getToken()->oid().second;
+ }
+ form.insertParam((unsigned int)(keyPos) * 0x00010000U + 0x0000FFFFU);
+ form.insertParam((unsigned int)(guidIdx) * 0x00010000U + (unsigned int)(classIdx));
+ form.insertParam((unsigned int)(prefixIdx) * 0x00010000U + (unsigned int)(typeIdx));
+ form.insertParam(tech);
+ form.insertParam(oid1);
+ unsigned int keyIdx = form.map().size(), aliasNum = trans->m_alias.size(), clidNum = trans->m_clids.size();
+ form.insertParam(keyIdx);
+ form.insertParam(aliasNum);
+ form.insertParam(clidNum);
+ form.insertMap(trans->m_key);
+ for (std::set<std::string>::const_iterator iter = trans->m_alias.begin(),
+ last = trans->m_alias.end(); iter != last; iter++) {
+ form.insertMap(*iter);
+ }
+ form.insertParam(trans->m_pClid);
+ for (std::set<CLID>::const_iterator iter = trans->m_clids.begin(),
+ last = trans->m_clids.end(); iter != last; iter++) {
+ form.insertParam(*iter);
+ }
+ for (std::vector<unsigned int>::const_iterator iter = trans->m_hashes.begin(),
+ last = trans->m_hashes.end(); iter != last; iter++) {
+ form.insertParam(*iter);
+ }
+}
+//______________________________________________________________________________
+//______________________________________________________________________________
+DataHeaderCnv_p5::DataHeaderCnv_p5() {}
+DataHeaderCnv_p5::~DataHeaderCnv_p5() {}
+//______________________________________________________________________________
+void DataHeaderCnv_p5::persToTrans(const DataHeader_p5* pers, DataHeader* trans) {
+ pers->m_dhForm.start();
+ const unsigned int provSize = pers->m_dhForm.params()[0];
+ trans->m_inputDataHeader.resize(provSize);
+ std::vector<DataHeaderElement>::iterator it = trans->m_inputDataHeader.begin();
+ std::vector<DataHeaderElement_p5>::const_iterator pit = pers->m_dataHeader.begin();
+ for (unsigned int i = 0U; i < provSize; i++, it++, pit++) {
+ pers->m_dhForm.next();
+ m_elemCnv.persToTrans(&(*pit), &(*it), pers->m_dhForm);
+ }
+ trans->m_dataHeader.resize(pers->m_dataHeader.size() - provSize);
+ it = trans->m_dataHeader.begin();
+ for (std::vector<DataHeaderElement_p5>::const_iterator last = pers->m_dataHeader.end();
+ pit != last; it++, pit++) {
+ pers->m_dhForm.next();
+ m_elemCnv.persToTrans(&(*pit), &(*it), pers->m_dhForm);
+ }
+}
+//______________________________________________________________________________
+void DataHeaderCnv_p5::transToPers(const DataHeader* trans, DataHeader_p5* pers) {
+ const unsigned int provSize = trans->m_inputDataHeader.size();
+ pers->m_dataHeader.resize(provSize + trans->m_dataHeader.size());
+ pers->m_dhForm.resize(provSize + trans->m_dataHeader.size() + 2);
+ pers->m_dhForm.start();
+ pers->m_dhForm.insertParam(provSize);
+ std::vector<DataHeaderElement_p5>::iterator pit = pers->m_dataHeader.begin();
+ for (std::vector<DataHeaderElement>::const_iterator it = trans->m_inputDataHeader.begin(),
+ last = trans->m_inputDataHeader.end(); it != last; it++, pit++) {
+ pers->m_dhForm.next();
+ m_elemCnv.transToPers(&(*it), &(*pit), pers->m_dhForm);
+ }
+ for (std::vector<DataHeaderElement>::const_iterator it = trans->m_dataHeader.begin(),
+ last = trans->m_dataHeader.end(); it != last; it++, pit++) {
+ pers->m_dhForm.next();
+ m_elemCnv.transToPers(&(*it), &(*pit), pers->m_dhForm);
+ }
+}
+//______________________________________________________________________________
+void DataHeaderCnv_p5::insertDHRef(DataHeader_p5* pers,
+ const std::string& key,
+ const std::string& strToken) {
+ Token* token = new Token;
+ token->fromString(strToken);
+ DataHeaderElement tEle(ClassID_traits<DataHeader>::ID(), key, token);
+ DataHeaderElement_p5 pEle;
+ pers->m_dhForm.next();
+ m_elemCnv.transToPers(&tEle, &pEle, pers->m_dhForm);
+ pers->m_dataHeader.push_back(pEle);
+}
diff --git a/Database/PersistentDataModelTPCnv/src/DataHeaderCnv_p6.cxx b/Database/PersistentDataModelTPCnv/src/DataHeaderCnv_p6.cxx
new file mode 100755
index 00000000000..ca99a28c26f
--- /dev/null
+++ b/Database/PersistentDataModelTPCnv/src/DataHeaderCnv_p6.cxx
@@ -0,0 +1,111 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+/** @file DataHeaderCnv_p6.cxx
+ * @brief This file contains the implementation for the DataHeaderCnv_p6 class.
+ * @author Peter van Gemmeren <gemmeren@anl.gov>
+ * $Id: DataHeaderCnv_p6.cxx,v 1.3.2.2 2009-05-22 19:26:54 gemmeren Exp $
+ **/
+
+#define private public
+#define protected public
+#include "PersistentDataModel/DataHeader.h"
+#undef private
+#undef protected
+
+#include "PersistentDataModelTPCnv/DataHeaderCnv_p6.h"
+
+DataHeaderElementCnv_p6::DataHeaderElementCnv_p6() {}
+DataHeaderElementCnv_p6::~DataHeaderElementCnv_p6() {}
+
+//______________________________________________________________________________
+void DataHeaderElementCnv_p6::persToTrans(const DataHeaderElement_p6* pers,
+ DataHeaderElement* trans,
+ const DataHeaderForm_p6& form) {
+ delete trans->m_token; trans->m_token = new Token;
+ Token* token = const_cast<Token*>(trans->m_token);
+// Append DbGuid
+ token->setDb(form.getDbGuid(pers->m_dbIdx));
+ token->setTechnology(form.getDbTech(pers->m_dbIdx));
+// Append ClassId
+ token->setClassID(form.getObjClassId(pers->m_objIdx));
+ token->setOid(Token::OID_t(pers->m_oid1, pers->m_oid2));
+// StoreGate
+ trans->m_key = form.getObjKey(pers->m_objIdx);
+ trans->m_alias = form.getObjAlias(pers->m_objIdx);
+ trans->m_pClid = form.getObjType(pers->m_objIdx);
+ trans->m_clids = form.getObjSymLinks(pers->m_objIdx);
+ trans->m_hashes = form.getObjHashes(pers->m_objIdx);
+}
+//______________________________________________________________________________
+void DataHeaderElementCnv_p6::transToPers(const DataHeaderElement* trans,
+ DataHeaderElement_p6* pers,
+ DataHeaderForm_p6& form) {
+// Translate PoolToken
+ if (trans->getToken() != 0) {
+// Database GUID & Technology
+ DataHeaderForm_p6::DbRecord transDb(trans->getToken()->dbID(), trans->getToken()->technology());
+ pers->m_dbIdx = form.insertDb(transDb);
+// StoreGate Type/Key & persistent Class GUID
+ DataHeaderForm_p6::SgRecord transSg(trans->m_key, trans->m_pClid);
+ DataHeaderForm_p6::ObjRecord transObj(trans->getToken()->classID(), transSg);
+ pers->m_objIdx = form.insertObj(transObj, trans->m_alias, trans->m_clids, trans->m_hashes);
+ pers->m_oid1 = trans->getToken()->oid().first;
+ pers->m_oid2 = trans->getToken()->oid().second;
+ }
+}
+//______________________________________________________________________________
+//______________________________________________________________________________
+DataHeaderCnv_p6::DataHeaderCnv_p6() {}
+DataHeaderCnv_p6::~DataHeaderCnv_p6() {}
+//______________________________________________________________________________
+void DataHeaderCnv_p6::persToTrans(const DataHeader_p6* pers, DataHeader* trans) {
+ pers->m_dhForm.start();
+ const unsigned int provSize = pers->m_provenanceSize;
+ trans->m_inputDataHeader.resize(provSize);
+ std::vector<DataHeaderElement>::iterator it = trans->m_inputDataHeader.begin();
+ std::vector<DataHeaderElement_p6>::const_iterator pit = pers->m_dataHeader.begin();
+ for (unsigned int i = 0U; i < provSize; i++, it++, pit++) {
+ m_elemCnv.persToTrans(&(*pit), &(*it), pers->m_dhForm);
+ pers->m_dhForm.next();
+ }
+ trans->m_dataHeader.resize(pers->m_dataHeader.size() - provSize);
+ it = trans->m_dataHeader.begin();
+ for (std::vector<DataHeaderElement_p6>::const_iterator last = pers->m_dataHeader.end();
+ pit != last; it++, pit++) {
+ m_elemCnv.persToTrans(&(*pit), &(*it), pers->m_dhForm);
+ pers->m_dhForm.next();
+ }
+}
+//______________________________________________________________________________
+void DataHeaderCnv_p6::transToPers(const DataHeader* trans, DataHeader_p6* pers) {
+ const unsigned int provSize = trans->m_inputDataHeader.size();
+ pers->m_dataHeader.resize(provSize + trans->m_dataHeader.size());
+ pers->m_provenanceSize = provSize;
+ pers->m_dhForm.resize(provSize + trans->m_dataHeader.size() + 1);
+ pers->m_dhForm.start();
+ std::vector<DataHeaderElement_p6>::iterator pit = pers->m_dataHeader.begin();
+ for (std::vector<DataHeaderElement>::const_iterator it = trans->m_inputDataHeader.begin(),
+ last = trans->m_inputDataHeader.end(); it != last; it++, pit++) {
+ m_elemCnv.transToPers(&(*it), &(*pit), pers->m_dhForm);
+ pers->m_dhForm.next();
+ }
+ for (std::vector<DataHeaderElement>::const_iterator it = trans->m_dataHeader.begin(),
+ last = trans->m_dataHeader.end(); it != last; it++, pit++) {
+ m_elemCnv.transToPers(&(*it), &(*pit), pers->m_dhForm);
+ pers->m_dhForm.next();
+ }
+}
+//______________________________________________________________________________
+void DataHeaderCnv_p6::insertDHRef(DataHeader_p6* pers,
+ const std::string& key,
+ const std::string& strToken) {
+ Token* token = new Token;
+ token->fromString(strToken);
+ DataHeaderElement tEle(ClassID_traits<DataHeader>::ID(), key, token);
+ DataHeaderElement_p6 pEle;
+ pers->m_dhForm.next();
+ m_elemCnv.transToPers(&tEle, &pEle, pers->m_dhForm);
+ pers->m_dataHeader.push_back(pEle);
+}
diff --git a/Database/PersistentDataModelTPCnv/src/DataHeader_p3.cxx b/Database/PersistentDataModelTPCnv/src/DataHeader_p3.cxx
new file mode 100755
index 00000000000..e2287534ea7
--- /dev/null
+++ b/Database/PersistentDataModelTPCnv/src/DataHeader_p3.cxx
@@ -0,0 +1,106 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#include "PersistentDataModelTPCnv/DataHeader_p3.h"
+
+DataHeaderElement_p3::DataHeaderElement_p3() : m_clids(),
+ m_token(),
+ m_alias(),
+ m_technology(0U),
+ m_oid1(0U),
+ m_oid2(0U),
+ m_dbGuidIdx(0U),
+ m_classIdIdx(0U),
+ m_prefixIdx(0U),
+ m_keyPos(0U),
+ m_hashes() {}
+DataHeaderElement_p3::DataHeaderElement_p3(const DataHeaderElement_p3& rhs) : m_clids(rhs.m_clids),
+ m_token(rhs.m_token),
+ m_alias(rhs.m_alias),
+ m_technology(rhs.m_technology),
+ m_oid1(rhs.m_oid1),
+ m_oid2(rhs.m_oid2),
+ m_dbGuidIdx(rhs.m_dbGuidIdx),
+ m_classIdIdx(rhs.m_classIdIdx),
+ m_prefixIdx(rhs.m_prefixIdx),
+ m_keyPos(rhs.m_keyPos),
+ m_hashes(rhs.m_hashes) {}
+DataHeaderElement_p3::~DataHeaderElement_p3() {}
+
+DataHeaderElement_p3& DataHeaderElement_p3::operator=(const DataHeaderElement_p3& rhs) {
+ if (this != &rhs) {
+ m_clids = rhs.m_clids;
+ m_token = rhs.m_token;
+ m_alias = rhs.m_alias;
+ m_technology = rhs.m_technology;
+ m_oid1 = rhs.m_oid1;
+ m_oid2 = rhs.m_oid2;
+ m_dbGuidIdx = rhs.m_dbGuidIdx;
+ m_classIdIdx = rhs.m_classIdIdx;
+ m_keyPos = rhs.m_keyPos;
+ m_hashes = rhs.m_hashes;
+ }
+ return(*this);
+}
+
+const std::vector<unsigned int>& DataHeaderElement_p3::clids() const {
+ return(m_clids);
+}
+
+const std::string& DataHeaderElement_p3::token() const {
+ return(m_token);
+}
+
+const std::vector<std::string> DataHeaderElement_p3::alias() const {
+ return(m_alias);
+}
+
+const std::string& DataHeaderElement_p3::key() const {
+ return(m_alias.front());
+}
+
+unsigned int DataHeaderElement_p3::pClid() const {
+ return(m_clids.front());
+}
+
+unsigned int DataHeaderElement_p3::oid1() const {
+ return(m_oid1);
+}
+
+unsigned int DataHeaderElement_p3::oid2() const {
+ return(m_oid2);
+}
+
+void DataHeaderElement_p3::overwriteOid2(unsigned int oid2) {
+ m_oid2 = oid2;
+}
+
+
+DataHeader_p3::DataHeader_p3()
+ : m_DataHeader(), m_InputDataHeader(), m_GuidMap() {}
+DataHeader_p3::DataHeader_p3(const DataHeader_p3& rhs) : m_DataHeader(rhs.m_DataHeader),
+ m_InputDataHeader(rhs.m_InputDataHeader),
+ m_GuidMap(rhs.m_GuidMap) {}
+DataHeader_p3::~DataHeader_p3() {}
+
+DataHeader_p3& DataHeader_p3::operator=(const DataHeader_p3& rhs) {
+ if (this != &rhs) {
+ m_DataHeader = rhs.m_DataHeader;
+ m_InputDataHeader = rhs.m_InputDataHeader;
+ m_GuidMap = rhs.m_GuidMap;
+ }
+ return(*this);
+}
+
+const std::vector<DataHeaderElement_p3>& DataHeader_p3::elements() const {
+ return(m_DataHeader);
+}
+
+const std::vector<DataHeaderElement_p3>& DataHeader_p3::inputElements() const {
+ return(m_InputDataHeader);
+}
+
+const std::vector<std::string>& DataHeader_p3::GuidMap() const {
+ return(m_GuidMap);
+}
diff --git a/Database/PersistentDataModelTPCnv/src/DataHeader_p4.cxx b/Database/PersistentDataModelTPCnv/src/DataHeader_p4.cxx
new file mode 100755
index 00000000000..a786afdc33c
--- /dev/null
+++ b/Database/PersistentDataModelTPCnv/src/DataHeader_p4.cxx
@@ -0,0 +1,105 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#include "PersistentDataModelTPCnv/DataHeader_p4.h"
+
+DataHeaderElement_p4::DataHeaderElement_p4() : m_clids(),
+ m_token(),
+ m_alias(),
+ m_technology(0U),
+ m_oid1(0U),
+ m_oid2(0U),
+ m_dbGuidIdx(0U),
+ m_classIdIdx(0U),
+ m_prefixIdx(0U),
+ m_keyPos(0U),
+ m_hashes() {}
+DataHeaderElement_p4::DataHeaderElement_p4(const DataHeaderElement_p4& rhs) : m_clids(rhs.m_clids),
+ m_token(rhs.m_token),
+ m_alias(rhs.m_alias),
+ m_technology(rhs.m_technology),
+ m_oid1(rhs.m_oid1),
+ m_oid2(rhs.m_oid2),
+ m_dbGuidIdx(rhs.m_dbGuidIdx),
+ m_classIdIdx(rhs.m_classIdIdx),
+ m_prefixIdx(rhs.m_prefixIdx),
+ m_keyPos(rhs.m_keyPos),
+ m_hashes(rhs.m_hashes) {}
+DataHeaderElement_p4::~DataHeaderElement_p4() {}
+
+DataHeaderElement_p4& DataHeaderElement_p4::operator=(const DataHeaderElement_p4& rhs) {
+ if (this != &rhs) {
+ m_clids = rhs.m_clids;
+ m_token = rhs.m_token;
+ m_alias = rhs.m_alias;
+ m_technology = rhs.m_technology;
+ m_oid1 = rhs.m_oid1;
+ m_oid2 = rhs.m_oid2;
+ m_dbGuidIdx = rhs.m_dbGuidIdx;
+ m_classIdIdx = rhs.m_classIdIdx;
+ m_keyPos = rhs.m_keyPos;
+ m_hashes = rhs.m_hashes;
+ }
+ return(*this);
+}
+
+unsigned int DataHeaderElement_p4::pClid() const {
+ return(m_clids.front());
+}
+
+const std::vector<unsigned int>& DataHeaderElement_p4::clids() const {
+ return(m_clids);
+}
+
+const std::string& DataHeaderElement_p4::key() const {
+ return(m_alias.front());
+}
+
+const std::vector<std::string>& DataHeaderElement_p4::alias() const {
+ return(m_alias);
+}
+
+const std::string& DataHeaderElement_p4::token() const {
+ return(m_token);
+}
+
+unsigned int DataHeaderElement_p4::oid1() const {
+ return(m_oid1);
+}
+
+unsigned int DataHeaderElement_p4::oid2() const {
+ return(m_oid2);
+}
+
+void DataHeaderElement_p4::overwriteOid2(unsigned int oid2) {
+ m_oid2 = oid2;
+}
+
+
+DataHeader_p4::DataHeader_p4() : m_dataHeader(), m_provSize(0U), m_guidMap() {}
+DataHeader_p4::DataHeader_p4(const DataHeader_p4& rhs) : m_dataHeader(rhs.m_dataHeader),
+ m_provSize(rhs.m_provSize),
+ m_guidMap(rhs.m_guidMap) {}
+DataHeader_p4::~DataHeader_p4() {}
+
+DataHeader_p4& DataHeader_p4::operator=(const DataHeader_p4& rhs) {
+ if (this != &rhs) {
+ m_dataHeader = rhs.m_dataHeader;
+ m_provSize = rhs.m_provSize;
+ m_guidMap = rhs.m_guidMap;
+ }
+ return(*this);
+}
+
+const std::vector<DataHeaderElement_p4>& DataHeader_p4::elements() const {
+ return(m_dataHeader);
+}
+
+unsigned int DataHeader_p4::provenanceSize() const {
+ return(m_provSize);
+}
+
+const std::vector<std::string>& DataHeader_p4::guidMap() const {
+ return(m_guidMap);
+}
diff --git a/Database/PersistentDataModelTPCnv/src/DataHeader_p5.cxx b/Database/PersistentDataModelTPCnv/src/DataHeader_p5.cxx
new file mode 100755
index 00000000000..0d577295de6
--- /dev/null
+++ b/Database/PersistentDataModelTPCnv/src/DataHeader_p5.cxx
@@ -0,0 +1,143 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#include "PersistentDataModelTPCnv/DataHeader_p5.h"
+
+#include "CxxUtils/MD5.h"
+
+#include <uuid/uuid.h>
+#include <sstream>
+
+DataHeaderElement_p5::DataHeaderElement_p5() : m_token(), m_oid2(0U) {}
+DataHeaderElement_p5::DataHeaderElement_p5(const DataHeaderElement_p5& rhs) : m_token(rhs.m_token),
+ m_oid2(rhs.m_oid2) {}
+DataHeaderElement_p5::~DataHeaderElement_p5() {}
+
+DataHeaderElement_p5& DataHeaderElement_p5::operator=(const DataHeaderElement_p5& rhs) {
+ if (this != &rhs) {
+ m_token = rhs.m_token;
+ m_oid2 = rhs.m_oid2;
+ }
+ return(*this);
+}
+
+const std::string& DataHeaderElement_p5::token() const {
+ return(m_token);
+}
+
+unsigned int DataHeaderElement_p5::oid2() const {
+ return(m_oid2);
+}
+
+void DataHeaderElement_p5::overwriteOid2(unsigned int oid2) {
+ m_oid2 = oid2;
+}
+
+
+DataHeaderForm_p5::DataHeaderForm_p5() : m_map(), m_uints(), m_entry(0U) {}
+DataHeaderForm_p5::DataHeaderForm_p5(const DataHeaderForm_p5& rhs) : m_map(rhs.m_map), m_uints(rhs.m_uints), m_entry(0U) {}
+DataHeaderForm_p5::~DataHeaderForm_p5() {}
+DataHeaderForm_p5& DataHeaderForm_p5::operator=(const DataHeaderForm_p5& rhs) {
+ if (&rhs != this) {
+ m_map = rhs.m_map;
+ m_uints = rhs.m_uints;
+ m_entry = 0U;
+ }
+ return(*this);
+}
+
+const std::vector<std::string>& DataHeaderForm_p5::map() const {
+ return(m_map);
+}
+
+void DataHeaderForm_p5::insertMap(const std::string& element) {
+ m_map.push_back(element);
+}
+
+const std::vector<unsigned int>& DataHeaderForm_p5::params() const {
+ return(m_uints[m_entry - 1]);
+}
+
+void DataHeaderForm_p5::insertParam(unsigned int param) {
+ m_uints[m_entry - 1].push_back(param);
+}
+
+unsigned int DataHeaderForm_p5::entry() const {
+ return(m_entry);
+}
+
+void DataHeaderForm_p5::start() const {
+ m_entry = 1;
+}
+
+void DataHeaderForm_p5::next() const {
+ m_entry++;
+}
+
+unsigned int DataHeaderForm_p5::size() {
+ return(m_uints.size());
+}
+
+void DataHeaderForm_p5::resize(unsigned int size) {
+ m_uints.resize(size);
+}
+
+
+DataHeader_p5::DataHeader_p5() : m_dataHeader(), m_dhForm(), m_dhFormToken(), m_dhFormMdx() {}
+DataHeader_p5::DataHeader_p5(const DataHeader_p5& rhs) : m_dataHeader(rhs.m_dataHeader),
+ m_dhForm(rhs.m_dhForm),
+ m_dhFormToken(rhs.m_dhFormToken),
+ m_dhFormMdx(rhs.m_dhFormMdx) {}
+DataHeader_p5::~DataHeader_p5() {}
+
+DataHeader_p5& DataHeader_p5::operator=(const DataHeader_p5& rhs) {
+ if (this != &rhs) {
+ m_dataHeader = rhs.m_dataHeader;
+ m_dhForm = rhs.m_dhForm;
+ m_dhFormToken = rhs.m_dhFormToken;
+ m_dhFormMdx = rhs.m_dhFormMdx;
+ }
+ return(*this);
+}
+
+const std::vector<DataHeaderElement_p5>& DataHeader_p5::elements() const {
+ return(m_dataHeader);
+}
+
+const DataHeaderForm_p5& DataHeader_p5::dhForm() const {
+ return(m_dhForm);
+}
+
+void DataHeader_p5::setDhForm(const DataHeaderForm_p5& form) {
+ m_dhForm = form;
+}
+
+const std::string& DataHeader_p5::dhFormToken() const {
+ return(m_dhFormToken);
+}
+
+void DataHeader_p5::setDhFormToken(const std::string& formToken) {
+ m_dhFormToken = formToken;
+ std::ostringstream stream;
+ for (std::vector<std::string>::const_iterator iter = m_dhForm.map().begin(),
+ last = m_dhForm.map().end(); iter != last; iter++) {
+ stream << *iter << "\n";
+ }
+ for (m_dhForm.start(); m_dhForm.entry() <= m_dhForm.size(); m_dhForm.next()) {
+ for (std::vector<unsigned int>::const_iterator iter = m_dhForm.params().begin(),
+ last = m_dhForm.params().end(); iter != last; iter++) {
+ stream << *iter << ",";
+ }
+ stream << "\n";
+ }
+ MD5 checkSum((unsigned char*)stream.str().c_str(), stream.str().size());
+ uuid_t checkSumUuid;
+ checkSum.raw_digest((unsigned char*)(&checkSumUuid));
+ char text[37];
+ uuid_unparse_upper(checkSumUuid, text);
+ m_dhFormMdx = text;
+}
+const std::string& DataHeader_p5::dhFormMdx() const {
+ return(m_dhFormMdx);
+}
diff --git a/Database/PersistentDataModelTPCnv/src/DataHeader_p6.cxx b/Database/PersistentDataModelTPCnv/src/DataHeader_p6.cxx
new file mode 100755
index 00000000000..2095e2d6bea
--- /dev/null
+++ b/Database/PersistentDataModelTPCnv/src/DataHeader_p6.cxx
@@ -0,0 +1,221 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#include "PersistentDataModelTPCnv/DataHeader_p6.h"
+
+#include "CxxUtils/MD5.h"
+
+#include <uuid/uuid.h>
+#include <sstream>
+
+DataHeaderElement_p6::DataHeaderElement_p6() : m_token(), m_oid1(0ULL), m_oid2(0ULL) {}
+DataHeaderElement_p6::DataHeaderElement_p6(const DataHeaderElement_p6& rhs) : m_token(rhs.m_token),
+ m_oid1(rhs.m_oid1),
+ m_oid2(rhs.m_oid2),
+ m_dbIdx(rhs.m_dbIdx),
+ m_objIdx(rhs.m_objIdx) {}
+DataHeaderElement_p6::~DataHeaderElement_p6() {}
+
+DataHeaderElement_p6& DataHeaderElement_p6::operator=(const DataHeaderElement_p6& rhs) {
+ if (this != &rhs) {
+ m_token = rhs.m_token;
+ m_oid1 = rhs.m_oid1;
+ m_oid2 = rhs.m_oid2;
+ m_dbIdx = rhs.m_dbIdx;
+ m_objIdx = rhs.m_objIdx;
+ }
+ return(*this);
+}
+
+const std::string& DataHeaderElement_p6::token() const {
+ return(m_token);
+}
+
+unsigned long long DataHeaderElement_p6::oid1() const {
+ return(m_oid1);
+}
+
+unsigned long long DataHeaderElement_p6::oid2() const {
+ return(m_oid2);
+}
+
+void DataHeaderElement_p6::overwriteOid2(unsigned long long oid2) {
+ m_oid2 = oid2;
+}
+
+
+DataHeaderForm_p6::DataHeaderForm_p6() : m_uints(), m_dbRecords(), m_objRecords(), m_objAlias(), m_objSymLinks(), m_objHashes(), m_entry(0U) {}
+DataHeaderForm_p6::DataHeaderForm_p6(const DataHeaderForm_p6& rhs) : m_uints(rhs.m_uints), m_dbRecords(rhs.m_dbRecords), m_objRecords(rhs.m_objRecords), m_objAlias(rhs.m_objAlias), m_objSymLinks(rhs.m_objSymLinks), m_objHashes(rhs.m_objHashes), m_entry(0U) {}
+DataHeaderForm_p6::~DataHeaderForm_p6() {}
+DataHeaderForm_p6& DataHeaderForm_p6::operator=(const DataHeaderForm_p6& rhs) {
+ if (&rhs != this) {
+ m_uints = rhs.m_uints;
+ m_dbRecords = rhs.m_dbRecords;
+ m_objRecords = rhs.m_objRecords;
+ m_objAlias = rhs.m_objAlias;
+ m_objSymLinks = rhs.m_objSymLinks;
+ m_objHashes = rhs.m_objHashes;
+ m_entry = 0U;
+ }
+ return(*this);
+}
+
+unsigned int DataHeaderForm_p6::insertDb(const DbRecord& rec) {
+ unsigned int index = 0U;
+ for (std::vector<DbRecord>::const_iterator iter = m_dbRecords.begin(), last = m_dbRecords.end();
+ iter != last; iter++, index++) {
+ if (*iter == rec) break;
+ }
+ if (index == m_dbRecords.size()) {
+ m_dbRecords.push_back(rec);
+ }
+ return(index);
+}
+
+std::size_t DataHeaderForm_p6::sizeDb() const {
+ return(m_dbRecords.size());
+}
+
+Guid DataHeaderForm_p6::getDbGuid(unsigned int index) const {
+ return(m_dbRecords[index].first);
+}
+
+unsigned int DataHeaderForm_p6::getDbTech(unsigned int index) const {
+ return(m_dbRecords[index].second);
+}
+
+unsigned int DataHeaderForm_p6::insertObj(const ObjRecord& rec,
+ const std::set<std::string>& alias,
+ const std::set<unsigned int>& symLinks,
+ const std::vector<unsigned int>& hashes) {
+ unsigned int index = 0U;
+ for (std::vector<ObjRecord>::const_iterator iter = m_objRecords.begin(), last = m_objRecords.end();
+ iter != last; iter++, index++) {
+ if (*iter == rec) break;
+ }
+ if (index == m_objRecords.size()) {
+ m_objRecords.push_back(rec);
+ m_objAlias.push_back(std::vector<std::string>(alias.begin(), alias.end()));
+ m_objSymLinks.push_back(std::vector<unsigned int>(symLinks.begin(), symLinks.end()));
+ m_objHashes.push_back(hashes);
+ }
+ return(index);
+}
+
+std::size_t DataHeaderForm_p6::sizeObj() const {
+ return(m_objRecords.size());
+}
+
+std::string DataHeaderForm_p6::getObjKey(unsigned int index) const {
+ return(m_objRecords[index].second.first);
+}
+
+unsigned int DataHeaderForm_p6::getObjType(unsigned int index) const {
+ return(m_objRecords[index].second.second);
+}
+
+Guid DataHeaderForm_p6::getObjClassId(unsigned int index) const {
+ return(m_objRecords[index].first);
+}
+
+std::set<std::string> DataHeaderForm_p6::getObjAlias(unsigned int index) const {
+ return(std::set<std::string>(m_objAlias[index].begin(), m_objAlias[index].end()));
+}
+
+std::set<unsigned int> DataHeaderForm_p6::getObjSymLinks(unsigned int index) const {
+ return(std::set<unsigned int>(m_objSymLinks[index].begin(), m_objSymLinks[index].end()));
+}
+
+std::vector<unsigned int> DataHeaderForm_p6::getObjHashes(unsigned int index) const {
+ return(m_objHashes[index]);
+}
+
+
+
+const std::vector<unsigned int>& DataHeaderForm_p6::params() const {
+ return(m_uints[m_entry]);
+}
+
+void DataHeaderForm_p6::insertParam(unsigned int param) {
+ m_uints[m_entry].push_back(param);
+}
+
+unsigned int DataHeaderForm_p6::entry() const {
+ return(m_entry);
+}
+
+void DataHeaderForm_p6::start() const {
+ m_entry = 0;
+}
+
+void DataHeaderForm_p6::next() const {
+ m_entry++;
+}
+
+unsigned int DataHeaderForm_p6::size() const {
+ return(m_uints.size());
+}
+
+void DataHeaderForm_p6::resize(unsigned int size) {
+ m_uints.resize(size);
+}
+
+
+DataHeader_p6::DataHeader_p6() : m_dataHeader(), m_provenanceSize(0U), m_dhForm(), m_dhFormToken(), m_dhFormMdx() {}
+DataHeader_p6::DataHeader_p6(const DataHeader_p6& rhs) : m_dataHeader(rhs.m_dataHeader),
+ m_dhForm(rhs.m_dhForm),
+ m_dhFormToken(rhs.m_dhFormToken),
+ m_dhFormMdx(rhs.m_dhFormMdx) {}
+DataHeader_p6::~DataHeader_p6() {}
+
+DataHeader_p6& DataHeader_p6::operator=(const DataHeader_p6& rhs) {
+ if (this != &rhs) {
+ m_dataHeader = rhs.m_dataHeader;
+ m_provenanceSize = rhs.m_provenanceSize;
+ m_dhForm = rhs.m_dhForm;
+ m_dhFormToken = rhs.m_dhFormToken;
+ m_dhFormMdx = rhs.m_dhFormMdx;
+ }
+ return(*this);
+}
+
+const std::vector<DataHeaderElement_p6>& DataHeader_p6::elements() const {
+ return(m_dataHeader);
+}
+
+const DataHeaderForm_p6& DataHeader_p6::dhForm() const {
+ return(m_dhForm);
+}
+
+void DataHeader_p6::setDhForm(const DataHeaderForm_p6& form) {
+ m_dhForm = form;
+}
+
+const std::string& DataHeader_p6::dhFormToken() const {
+ return(m_dhFormToken);
+}
+
+void DataHeader_p6::setDhFormToken(const std::string& formToken) {
+ m_dhFormToken = formToken;
+}
+
+void DataHeader_p6::calculateDhFormMdx() {
+ std::ostringstream stream;
+ for (std::size_t iter = 0, last = m_dhForm.sizeDb(); iter != last; iter++) {
+ stream << m_dhForm.getDbGuid(iter) << "," << m_dhForm.getDbTech(iter) << "\n";
+ }
+ for (std::size_t iter = 0, last = m_dhForm.sizeObj(); iter != last; iter++) {
+ stream << m_dhForm.getObjKey(iter) << "," << m_dhForm.getObjType(iter) << "," << m_dhForm.getObjClassId(iter) << "\n";
+ }
+ MD5 checkSum((unsigned char*)stream.str().c_str(), stream.str().size());
+ uuid_t checkSumUuid;
+ checkSum.raw_digest((unsigned char*)(&checkSumUuid));
+ char text[37];
+ uuid_unparse_upper(checkSumUuid, text);
+ m_dhFormMdx = text;
+}
+
+const std::string& DataHeader_p6::dhFormMdx() const {
+ return(m_dhFormMdx);
+}
--
GitLab