From 38df1f8658356ec79e6d60ac98af955b57c61721 Mon Sep 17 00:00:00 2001
From: Daniele Kruse <dkruse@cern.ch>
Date: Fri, 29 Apr 2016 10:46:57 +0200
Subject: [PATCH] Namespaced all data structures .cpp's

---
 common/dataStructures/AdminHost.cpp               | 15 +++++++++++----
 common/dataStructures/AdminHost.hpp               |  8 ++++----
 common/dataStructures/AdminUser.cpp               | 15 +++++++++++----
 common/dataStructures/AdminUser.hpp               |  8 ++++----
 common/dataStructures/ArchiveFile.cpp             | 15 +++++++++++----
 common/dataStructures/ArchiveFile.hpp             |  8 ++++----
 common/dataStructures/ArchiveFileSummary.cpp      | 15 +++++++++++----
 common/dataStructures/ArchiveFileSummary.hpp      |  4 ++--
 common/dataStructures/ArchiveJob.cpp              | 15 +++++++++++----
 common/dataStructures/ArchiveJob.hpp              |  6 +++---
 common/dataStructures/ArchiveRequest.cpp          | 15 +++++++++++----
 common/dataStructures/ArchiveRequest.hpp          | 10 +++++-----
 common/dataStructures/ArchiveRoute.cpp            | 15 +++++++++++----
 common/dataStructures/ArchiveRoute.hpp            |  8 ++++----
 common/dataStructures/CancelRetrieveRequest.cpp   | 15 +++++++++++----
 common/dataStructures/CancelRetrieveRequest.hpp   |  8 ++++----
 common/dataStructures/DRData.cpp                  | 15 +++++++++++----
 common/dataStructures/DRData.hpp                  |  4 ++--
 common/dataStructures/Dedication.cpp              | 15 +++++++++++----
 common/dataStructures/Dedication.hpp              | 10 +++++-----
 common/dataStructures/DeleteArchiveRequest.cpp    | 15 +++++++++++----
 common/dataStructures/DeleteArchiveRequest.hpp    |  6 +++---
 common/dataStructures/DriveState.cpp              | 15 +++++++++++----
 common/dataStructures/DriveState.hpp              |  8 ++++----
 common/dataStructures/EntryLog.cpp                | 15 +++++++++++----
 common/dataStructures/EntryLog.hpp                |  6 +++---
 common/dataStructures/ListStorageClassRequest.cpp | 15 +++++++++++----
 common/dataStructures/ListStorageClassRequest.hpp |  6 +++---
 common/dataStructures/LogicalLibrary.cpp          | 15 +++++++++++----
 common/dataStructures/LogicalLibrary.hpp          |  8 ++++----
 common/dataStructures/MountPolicy.cpp             | 15 +++++++++++----
 common/dataStructures/MountPolicy.hpp             |  8 ++++----
 common/dataStructures/ReadTestResult.cpp          | 15 +++++++++++----
 common/dataStructures/ReadTestResult.hpp          |  4 ++--
 common/dataStructures/RepackInfo.cpp              | 15 +++++++++++----
 common/dataStructures/RepackInfo.hpp              |  8 ++++----
 common/dataStructures/Requester.cpp               | 15 +++++++++++----
 common/dataStructures/Requester.hpp               |  8 ++++----
 common/dataStructures/RetrieveJob.cpp             | 15 +++++++++++----
 common/dataStructures/RetrieveJob.hpp             |  8 ++++----
 common/dataStructures/RetrieveRequest.cpp         | 15 +++++++++++----
 common/dataStructures/RetrieveRequest.hpp         | 10 +++++-----
 common/dataStructures/SecurityIdentity.cpp        | 15 +++++++++++----
 common/dataStructures/SecurityIdentity.hpp        |  6 +++---
 common/dataStructures/StorageClass.cpp            | 15 +++++++++++----
 common/dataStructures/StorageClass.hpp            |  8 ++++----
 common/dataStructures/Tape.cpp                    | 15 +++++++++++----
 common/dataStructures/Tape.hpp                    | 14 +++++++-------
 common/dataStructures/TapeFile.cpp                | 15 +++++++++++----
 common/dataStructures/TapeFile.hpp                |  4 ++--
 common/dataStructures/TapeLog.cpp                 | 15 +++++++++++----
 common/dataStructures/TapeLog.hpp                 |  4 ++--
 common/dataStructures/TapePool.cpp                | 15 +++++++++++----
 common/dataStructures/TapePool.hpp                |  8 ++++----
 common/dataStructures/UpdateFileInfoRequest.cpp   | 15 +++++++++++----
 common/dataStructures/UpdateFileInfoRequest.hpp   |  6 +++---
 .../UpdateFileStorageClassRequest.cpp             | 15 +++++++++++----
 .../UpdateFileStorageClassRequest.hpp             |  8 ++++----
 common/dataStructures/UserIdentity.cpp            |  6 +++---
 common/dataStructures/UserIdentity.hpp            |  6 ++++--
 common/dataStructures/VerifyInfo.cpp              | 15 +++++++++++----
 common/dataStructures/VerifyInfo.hpp              |  6 +++---
 common/dataStructures/WriteTestResult.cpp         | 15 +++++++++++----
 common/dataStructures/WriteTestResult.hpp         |  4 ++--
 common/dataStructures/utils.cpp                   | 14 +++++++++++---
 common/dataStructures/utils.hpp                   | 14 +++++++++++---
 66 files changed, 481 insertions(+), 246 deletions(-)

diff --git a/common/dataStructures/AdminHost.cpp b/common/dataStructures/AdminHost.cpp
index b63f69ce0f..ca90283695 100644
--- a/common/dataStructures/AdminHost.cpp
+++ b/common/dataStructures/AdminHost.cpp
@@ -20,15 +20,19 @@
 #include "common/dataStructures/utils.hpp"
 #include "common/exception/Exception.hpp"
 
+namespace cta {
+namespace common {
+namespace dataStructures {
+
 //------------------------------------------------------------------------------
 // constructor
 //------------------------------------------------------------------------------
-cta::common::dataStructures::AdminHost::AdminHost() {}
+AdminHost::AdminHost() {}
 
 //------------------------------------------------------------------------------
 // operator==
 //------------------------------------------------------------------------------
-bool cta::common::dataStructures::AdminHost::operator==(const AdminHost &rhs) const {
+bool AdminHost::operator==(const AdminHost &rhs) const {
   return name==rhs.name
       && creationLog==rhs.creationLog
       && lastModificationLog==rhs.lastModificationLog
@@ -38,14 +42,14 @@ bool cta::common::dataStructures::AdminHost::operator==(const AdminHost &rhs) co
 //------------------------------------------------------------------------------
 // operator!=
 //------------------------------------------------------------------------------
-bool cta::common::dataStructures::AdminHost::operator!=(const AdminHost &rhs) const {
+bool AdminHost::operator!=(const AdminHost &rhs) const {
   return !operator==(rhs);
 }
 
 //------------------------------------------------------------------------------
 // operator<<
 //------------------------------------------------------------------------------
-std::ostream &operator<<(std::ostream &os, const cta::common::dataStructures::AdminHost &obj) {
+std::ostream &operator<<(std::ostream &os, const AdminHost &obj) {
   os << "(name=" << obj.name
      << " creationLog=" << obj.creationLog
      << " lastModificationLog=" << obj.lastModificationLog
@@ -53,3 +57,6 @@ std::ostream &operator<<(std::ostream &os, const cta::common::dataStructures::Ad
   return os;
 }
 
+} // namespace dataStructures
+} // namespace common
+} // namespace cta
diff --git a/common/dataStructures/AdminHost.hpp b/common/dataStructures/AdminHost.hpp
index e60ea093a3..7dfdb008a2 100644
--- a/common/dataStructures/AdminHost.hpp
+++ b/common/dataStructures/AdminHost.hpp
@@ -41,14 +41,14 @@ struct AdminHost {
   bool operator!=(const AdminHost &rhs) const;
 
   std::string name;
-  cta::common::dataStructures::EntryLog creationLog;
-  cta::common::dataStructures::EntryLog lastModificationLog;
+  EntryLog creationLog;
+  EntryLog lastModificationLog;
   std::string comment;
 
 }; // struct AdminHost
 
+std::ostream &operator<<(std::ostream &os, const AdminHost &obj);
+
 } // namespace dataStructures
 } // namespace common
 } // namespace cta
-
-std::ostream &operator<<(std::ostream &os, const cta::common::dataStructures::AdminHost &obj);
diff --git a/common/dataStructures/AdminUser.cpp b/common/dataStructures/AdminUser.cpp
index 92f33352f8..829bf04940 100644
--- a/common/dataStructures/AdminUser.cpp
+++ b/common/dataStructures/AdminUser.cpp
@@ -20,15 +20,19 @@
 #include "common/dataStructures/utils.hpp"
 #include "common/exception/Exception.hpp"
 
+namespace cta {
+namespace common {
+namespace dataStructures {
+
 //------------------------------------------------------------------------------
 // constructor
 //------------------------------------------------------------------------------
-cta::common::dataStructures::AdminUser::AdminUser() {}
+AdminUser::AdminUser() {}
 
 //------------------------------------------------------------------------------
 // operator==
 //------------------------------------------------------------------------------
-bool cta::common::dataStructures::AdminUser::operator==(const AdminUser &rhs) const {
+bool AdminUser::operator==(const AdminUser &rhs) const {
   return name==rhs.name
       && creationLog==rhs.creationLog
       && lastModificationLog==rhs.lastModificationLog
@@ -38,14 +42,14 @@ bool cta::common::dataStructures::AdminUser::operator==(const AdminUser &rhs) co
 //------------------------------------------------------------------------------
 // operator!=
 //------------------------------------------------------------------------------
-bool cta::common::dataStructures::AdminUser::operator!=(const AdminUser &rhs) const {
+bool AdminUser::operator!=(const AdminUser &rhs) const {
   return !operator==(rhs);
 }
 
 //------------------------------------------------------------------------------
 // operator<<
 //------------------------------------------------------------------------------
-std::ostream &operator<<(std::ostream &os, const cta::common::dataStructures::AdminUser &obj) {
+std::ostream &operator<<(std::ostream &os, const AdminUser &obj) {
   os << "(name=" << obj.name
      << " creationLog=" << obj.creationLog
      << " lastModificationLog=" << obj.lastModificationLog
@@ -53,3 +57,6 @@ std::ostream &operator<<(std::ostream &os, const cta::common::dataStructures::Ad
   return os;
 }
 
+} // namespace dataStructures
+} // namespace common
+} // namespace cta
diff --git a/common/dataStructures/AdminUser.hpp b/common/dataStructures/AdminUser.hpp
index 4336d02f27..9525fae8cf 100644
--- a/common/dataStructures/AdminUser.hpp
+++ b/common/dataStructures/AdminUser.hpp
@@ -41,14 +41,14 @@ struct AdminUser {
   bool operator!=(const AdminUser &rhs) const;
 
   std::string name;
-  cta::common::dataStructures::EntryLog creationLog;
-  cta::common::dataStructures::EntryLog lastModificationLog;
+  EntryLog creationLog;
+  EntryLog lastModificationLog;
   std::string comment;
 
 }; // struct AdminUser
 
+std::ostream &operator<<(std::ostream &os, const AdminUser &obj);
+
 } // namespace dataStructures
 } // namespace common
 } // namespace cta
-
-std::ostream &operator<<(std::ostream &os, const cta::common::dataStructures::AdminUser &obj);
diff --git a/common/dataStructures/ArchiveFile.cpp b/common/dataStructures/ArchiveFile.cpp
index b527377f86..5964883a11 100644
--- a/common/dataStructures/ArchiveFile.cpp
+++ b/common/dataStructures/ArchiveFile.cpp
@@ -20,10 +20,14 @@
 #include "common/dataStructures/utils.hpp"
 #include "common/exception/Exception.hpp"
 
+namespace cta {
+namespace common {
+namespace dataStructures {
+
 //------------------------------------------------------------------------------
 // constructor
 //------------------------------------------------------------------------------
-cta::common::dataStructures::ArchiveFile::ArchiveFile():
+ArchiveFile::ArchiveFile():
   archiveFileID(0),
   fileSize(0),
   creationTime(0),
@@ -32,7 +36,7 @@ cta::common::dataStructures::ArchiveFile::ArchiveFile():
 //------------------------------------------------------------------------------
 // operator==
 //------------------------------------------------------------------------------
-bool cta::common::dataStructures::ArchiveFile::operator==(const ArchiveFile &rhs) const {
+bool ArchiveFile::operator==(const ArchiveFile &rhs) const {
   return archiveFileID==rhs.archiveFileID
       && diskFileID==rhs.diskFileID
       && diskInstance==rhs.diskInstance
@@ -49,14 +53,14 @@ bool cta::common::dataStructures::ArchiveFile::operator==(const ArchiveFile &rhs
 //------------------------------------------------------------------------------
 // operator!=
 //------------------------------------------------------------------------------
-bool cta::common::dataStructures::ArchiveFile::operator!=(const ArchiveFile &rhs) const {
+bool ArchiveFile::operator!=(const ArchiveFile &rhs) const {
   return !operator==(rhs);
 }
 
 //------------------------------------------------------------------------------
 // operator<<
 //------------------------------------------------------------------------------
-std::ostream &operator<<(std::ostream &os, const cta::common::dataStructures::ArchiveFile &obj) {
+std::ostream &operator<<(std::ostream &os, const ArchiveFile &obj) {
   os << "(archiveFileID=" << obj.archiveFileID
      << " diskFileID=" << obj.diskFileID
      << " diskInstance=" << obj.diskInstance
@@ -71,3 +75,6 @@ std::ostream &operator<<(std::ostream &os, const cta::common::dataStructures::Ar
   return os;
 }
 
+} // namespace dataStructures
+} // namespace common
+} // namespace cta
diff --git a/common/dataStructures/ArchiveFile.hpp b/common/dataStructures/ArchiveFile.hpp
index 7b4b90e216..bef2a5eacb 100644
--- a/common/dataStructures/ArchiveFile.hpp
+++ b/common/dataStructures/ArchiveFile.hpp
@@ -54,20 +54,20 @@ struct ArchiveFile {
    */
   std::string checksumValue;
   std::string storageClass;
-  cta::common::dataStructures::DRData drData;
+  DRData drData;
   /**
    * This map represents the non-necessarily-exhaustive set of tape copies 
    * to be listed by the operator. For example, if the listing requested is 
    * for a single tape, the map will contain only one element. 
    */
-  std::map<uint64_t,cta::common::dataStructures::TapeFile> tapeCopies;
+  std::map<uint64_t,TapeFile> tapeCopies;
   time_t creationTime;
   time_t reconciliationTime;
 
 }; // struct ArchiveFile
 
+std::ostream &operator<<(std::ostream &os, const ArchiveFile &obj);
+
 } // namespace dataStructures
 } // namespace common
 } // namespace cta
-
-std::ostream &operator<<(std::ostream &os, const cta::common::dataStructures::ArchiveFile &obj);
diff --git a/common/dataStructures/ArchiveFileSummary.cpp b/common/dataStructures/ArchiveFileSummary.cpp
index c7dc8412ea..cc9ec8b86a 100644
--- a/common/dataStructures/ArchiveFileSummary.cpp
+++ b/common/dataStructures/ArchiveFileSummary.cpp
@@ -20,17 +20,21 @@
 #include "common/dataStructures/utils.hpp"
 #include "common/exception/Exception.hpp"
 
+namespace cta {
+namespace common {
+namespace dataStructures {
+
 //------------------------------------------------------------------------------
 // constructor
 //------------------------------------------------------------------------------
-cta::common::dataStructures::ArchiveFileSummary::ArchiveFileSummary():
+ArchiveFileSummary::ArchiveFileSummary():
   totalBytes(0),
   totalFiles(0) {}
 
 //------------------------------------------------------------------------------
 // operator==
 //------------------------------------------------------------------------------
-bool cta::common::dataStructures::ArchiveFileSummary::operator==(const ArchiveFileSummary &rhs) const {
+bool ArchiveFileSummary::operator==(const ArchiveFileSummary &rhs) const {
   return totalBytes==rhs.totalBytes
       && totalFiles==rhs.totalFiles;
 }
@@ -38,16 +42,19 @@ bool cta::common::dataStructures::ArchiveFileSummary::operator==(const ArchiveFi
 //------------------------------------------------------------------------------
 // operator!=
 //------------------------------------------------------------------------------
-bool cta::common::dataStructures::ArchiveFileSummary::operator!=(const ArchiveFileSummary &rhs) const {
+bool ArchiveFileSummary::operator!=(const ArchiveFileSummary &rhs) const {
   return !operator==(rhs);
 }
 
 //------------------------------------------------------------------------------
 // operator<<
 //------------------------------------------------------------------------------
-std::ostream &operator<<(std::ostream &os, const cta::common::dataStructures::ArchiveFileSummary &obj) {
+std::ostream &operator<<(std::ostream &os, const ArchiveFileSummary &obj) {
   os << "(totalBytes=" << obj.totalBytes
      << " totalFiles=" << obj.totalFiles << ")";
   return os;
 }
 
+} // namespace dataStructures
+} // namespace common
+} // namespace cta
diff --git a/common/dataStructures/ArchiveFileSummary.hpp b/common/dataStructures/ArchiveFileSummary.hpp
index dbc847fe0a..99ce39c511 100644
--- a/common/dataStructures/ArchiveFileSummary.hpp
+++ b/common/dataStructures/ArchiveFileSummary.hpp
@@ -44,8 +44,8 @@ struct ArchiveFileSummary {
 
 }; // struct ArchiveFileSummary
 
+std::ostream &operator<<(std::ostream &os, const ArchiveFileSummary &obj);
+
 } // namespace dataStructures
 } // namespace common
 } // namespace cta
-
-std::ostream &operator<<(std::ostream &os, const cta::common::dataStructures::ArchiveFileSummary &obj);
diff --git a/common/dataStructures/ArchiveJob.cpp b/common/dataStructures/ArchiveJob.cpp
index 00e003e650..231b409045 100644
--- a/common/dataStructures/ArchiveJob.cpp
+++ b/common/dataStructures/ArchiveJob.cpp
@@ -20,17 +20,21 @@
 #include "common/dataStructures/utils.hpp"
 #include "common/exception/Exception.hpp"
 
+namespace cta {
+namespace common {
+namespace dataStructures {
+
 //------------------------------------------------------------------------------
 // constructor
 //------------------------------------------------------------------------------
-cta::common::dataStructures::ArchiveJob::ArchiveJob():
+ArchiveJob::ArchiveJob():
   copyNumber(0),
   archiveFileID(0) {}
 
 //------------------------------------------------------------------------------
 // operator==
 //------------------------------------------------------------------------------
-bool cta::common::dataStructures::ArchiveJob::operator==(const ArchiveJob &rhs) const {
+bool ArchiveJob::operator==(const ArchiveJob &rhs) const {
   return request==rhs.request
       && tapePool==rhs.tapePool
       && copyNumber==rhs.copyNumber
@@ -40,14 +44,14 @@ bool cta::common::dataStructures::ArchiveJob::operator==(const ArchiveJob &rhs)
 //------------------------------------------------------------------------------
 // operator!=
 //------------------------------------------------------------------------------
-bool cta::common::dataStructures::ArchiveJob::operator!=(const ArchiveJob &rhs) const {
+bool ArchiveJob::operator!=(const ArchiveJob &rhs) const {
   return !operator==(rhs);
 }
 
 //------------------------------------------------------------------------------
 // operator<<
 //------------------------------------------------------------------------------
-std::ostream &operator<<(std::ostream &os, const cta::common::dataStructures::ArchiveJob &obj) {
+std::ostream &operator<<(std::ostream &os, const ArchiveJob &obj) {
   os << "(request=" << obj.request
      << " tapePool=" << obj.tapePool
      << " copyNumber=" << obj.copyNumber
@@ -55,3 +59,6 @@ std::ostream &operator<<(std::ostream &os, const cta::common::dataStructures::Ar
   return os;
 }
 
+} // namespace dataStructures
+} // namespace common
+} // namespace cta
diff --git a/common/dataStructures/ArchiveJob.hpp b/common/dataStructures/ArchiveJob.hpp
index 4c94abab4c..4aeeb27fce 100644
--- a/common/dataStructures/ArchiveJob.hpp
+++ b/common/dataStructures/ArchiveJob.hpp
@@ -41,15 +41,15 @@ struct ArchiveJob {
 
   bool operator!=(const ArchiveJob &rhs) const;
 
-  cta::common::dataStructures::ArchiveRequest request;
+  ArchiveRequest request;
   std::string tapePool;
   uint64_t copyNumber;
   uint64_t archiveFileID;
 
 }; // struct ArchiveJob
 
+std::ostream &operator<<(std::ostream &os, const ArchiveJob &obj);
+
 } // namespace dataStructures
 } // namespace common
 } // namespace cta
-
-std::ostream &operator<<(std::ostream &os, const cta::common::dataStructures::ArchiveJob &obj);
diff --git a/common/dataStructures/ArchiveRequest.cpp b/common/dataStructures/ArchiveRequest.cpp
index 711a31166c..f977d8f9e1 100644
--- a/common/dataStructures/ArchiveRequest.cpp
+++ b/common/dataStructures/ArchiveRequest.cpp
@@ -20,17 +20,21 @@
 #include "common/dataStructures/utils.hpp"
 #include "common/exception/Exception.hpp"
 
+namespace cta {
+namespace common {
+namespace dataStructures {
+
 //------------------------------------------------------------------------------
 // constructor
 //------------------------------------------------------------------------------
-cta::common::dataStructures::ArchiveRequest::ArchiveRequest():
+ArchiveRequest::ArchiveRequest():
   fileSize(0),
   diskpoolThroughput(0) {}
 
 //------------------------------------------------------------------------------
 // operator==
 //------------------------------------------------------------------------------
-bool cta::common::dataStructures::ArchiveRequest::operator==(const ArchiveRequest &rhs) const {
+bool ArchiveRequest::operator==(const ArchiveRequest &rhs) const {
   return requester==rhs.requester
       && diskFileID==rhs.diskFileID
       && instance==rhs.instance
@@ -48,14 +52,14 @@ bool cta::common::dataStructures::ArchiveRequest::operator==(const ArchiveReques
 //------------------------------------------------------------------------------
 // operator!=
 //------------------------------------------------------------------------------
-bool cta::common::dataStructures::ArchiveRequest::operator!=(const ArchiveRequest &rhs) const {
+bool ArchiveRequest::operator!=(const ArchiveRequest &rhs) const {
   return !operator==(rhs);
 }
 
 //------------------------------------------------------------------------------
 // operator<<
 //------------------------------------------------------------------------------
-std::ostream &operator<<(std::ostream &os, const cta::common::dataStructures::ArchiveRequest &obj) {
+std::ostream &operator<<(std::ostream &os, const ArchiveRequest &obj) {
   os << "(requester=" << obj.requester
      << " diskFileID=" << obj.diskFileID
      << " instance=" << obj.instance
@@ -71,3 +75,6 @@ std::ostream &operator<<(std::ostream &os, const cta::common::dataStructures::Ar
   return os;
 }
 
+} // namespace dataStructures
+} // namespace common
+} // namespace cta
diff --git a/common/dataStructures/ArchiveRequest.hpp b/common/dataStructures/ArchiveRequest.hpp
index 5ff60f35d2..801b7c3dd6 100644
--- a/common/dataStructures/ArchiveRequest.hpp
+++ b/common/dataStructures/ArchiveRequest.hpp
@@ -42,7 +42,7 @@ struct ArchiveRequest {
 
   bool operator!=(const ArchiveRequest &rhs) const;
 
-  cta::common::dataStructures::UserIdentity requester;
+  UserIdentity requester;
   std::string diskFileID;
   std::string instance;
   std::string srcURL;
@@ -56,15 +56,15 @@ struct ArchiveRequest {
    */
   std::string checksumValue;
   std::string storageClass;
-  cta::common::dataStructures::DRData drData;
+  DRData drData;
   std::string diskpoolName;
   uint64_t diskpoolThroughput;
-  cta::common::dataStructures::EntryLog creationLog;
+  EntryLog creationLog;
 
 }; // struct ArchiveRequest
 
+std::ostream &operator<<(std::ostream &os, const ArchiveRequest &obj);
+
 } // namespace dataStructures
 } // namespace common
 } // namespace cta
-
-std::ostream &operator<<(std::ostream &os, const cta::common::dataStructures::ArchiveRequest &obj);
diff --git a/common/dataStructures/ArchiveRoute.cpp b/common/dataStructures/ArchiveRoute.cpp
index cdec6c386e..09836ddafe 100644
--- a/common/dataStructures/ArchiveRoute.cpp
+++ b/common/dataStructures/ArchiveRoute.cpp
@@ -20,16 +20,20 @@
 #include "common/dataStructures/utils.hpp"
 #include "common/exception/Exception.hpp"
 
+namespace cta {
+namespace common {
+namespace dataStructures {
+
 //------------------------------------------------------------------------------
 // constructor
 //------------------------------------------------------------------------------
-cta::common::dataStructures::ArchiveRoute::ArchiveRoute():
+ArchiveRoute::ArchiveRoute():
   copyNb(0) {}
 
 //------------------------------------------------------------------------------
 // operator==
 //------------------------------------------------------------------------------
-bool cta::common::dataStructures::ArchiveRoute::operator==(const ArchiveRoute &rhs) const {
+bool ArchiveRoute::operator==(const ArchiveRoute &rhs) const {
   return storageClassName==rhs.storageClassName
       && copyNb==rhs.copyNb
       && tapePoolName==rhs.tapePoolName
@@ -41,14 +45,14 @@ bool cta::common::dataStructures::ArchiveRoute::operator==(const ArchiveRoute &r
 //------------------------------------------------------------------------------
 // operator!=
 //------------------------------------------------------------------------------
-bool cta::common::dataStructures::ArchiveRoute::operator!=(const ArchiveRoute &rhs) const {
+bool ArchiveRoute::operator!=(const ArchiveRoute &rhs) const {
   return !operator==(rhs);
 }
 
 //------------------------------------------------------------------------------
 // operator<<
 //------------------------------------------------------------------------------
-std::ostream &operator<<(std::ostream &os, const cta::common::dataStructures::ArchiveRoute &obj) {
+std::ostream &operator<<(std::ostream &os, const ArchiveRoute &obj) {
   os << "(storageClassName=" << obj.storageClassName
      << " copyNb=" << obj.copyNb
      << " tapePoolName=" << obj.tapePoolName
@@ -58,3 +62,6 @@ std::ostream &operator<<(std::ostream &os, const cta::common::dataStructures::Ar
   return os;
 }
 
+} // namespace dataStructures
+} // namespace common
+} // namespace cta
diff --git a/common/dataStructures/ArchiveRoute.hpp b/common/dataStructures/ArchiveRoute.hpp
index 4ed86ee5ef..b73ac7d3b3 100644
--- a/common/dataStructures/ArchiveRoute.hpp
+++ b/common/dataStructures/ArchiveRoute.hpp
@@ -44,14 +44,14 @@ struct ArchiveRoute {
   std::string storageClassName;
   uint64_t copyNb;
   std::string tapePoolName;
-  cta::common::dataStructures::EntryLog creationLog;
-  cta::common::dataStructures::EntryLog lastModificationLog;
+  EntryLog creationLog;
+  EntryLog lastModificationLog;
   std::string comment;
 
 }; // struct ArchiveRoute
 
+std::ostream &operator<<(std::ostream &os, const ArchiveRoute &obj);
+
 } // namespace dataStructures
 } // namespace common
 } // namespace cta
-
-std::ostream &operator<<(std::ostream &os, const cta::common::dataStructures::ArchiveRoute &obj);
diff --git a/common/dataStructures/CancelRetrieveRequest.cpp b/common/dataStructures/CancelRetrieveRequest.cpp
index e308c542c3..d4675c542d 100644
--- a/common/dataStructures/CancelRetrieveRequest.cpp
+++ b/common/dataStructures/CancelRetrieveRequest.cpp
@@ -20,16 +20,20 @@
 #include "common/dataStructures/utils.hpp"
 #include "common/exception/Exception.hpp"
 
+namespace cta {
+namespace common {
+namespace dataStructures {
+
 //------------------------------------------------------------------------------
 // constructor
 //------------------------------------------------------------------------------
-cta::common::dataStructures::CancelRetrieveRequest::CancelRetrieveRequest():
+CancelRetrieveRequest::CancelRetrieveRequest():
   archiveFileID(0) {}
 
 //------------------------------------------------------------------------------
 // operator==
 //------------------------------------------------------------------------------
-bool cta::common::dataStructures::CancelRetrieveRequest::operator==(const CancelRetrieveRequest &rhs) const {
+bool CancelRetrieveRequest::operator==(const CancelRetrieveRequest &rhs) const {
   return requester==rhs.requester
       && archiveFileID==rhs.archiveFileID
       && dstURL==rhs.dstURL
@@ -39,14 +43,14 @@ bool cta::common::dataStructures::CancelRetrieveRequest::operator==(const Cancel
 //------------------------------------------------------------------------------
 // operator!=
 //------------------------------------------------------------------------------
-bool cta::common::dataStructures::CancelRetrieveRequest::operator!=(const CancelRetrieveRequest &rhs) const {
+bool CancelRetrieveRequest::operator!=(const CancelRetrieveRequest &rhs) const {
   return !operator==(rhs);
 }
 
 //------------------------------------------------------------------------------
 // operator<<
 //------------------------------------------------------------------------------
-std::ostream &operator<<(std::ostream &os, const cta::common::dataStructures::CancelRetrieveRequest &obj) {
+std::ostream &operator<<(std::ostream &os, const CancelRetrieveRequest &obj) {
   os << "(requester=" << obj.requester
      << " archiveFileID=" << obj.archiveFileID
      << " dstURL=" << obj.dstURL
@@ -54,3 +58,6 @@ std::ostream &operator<<(std::ostream &os, const cta::common::dataStructures::Ca
   return os;
 }
 
+} // namespace dataStructures
+} // namespace common
+} // namespace cta
diff --git a/common/dataStructures/CancelRetrieveRequest.hpp b/common/dataStructures/CancelRetrieveRequest.hpp
index b7f453e23d..70476c1895 100644
--- a/common/dataStructures/CancelRetrieveRequest.hpp
+++ b/common/dataStructures/CancelRetrieveRequest.hpp
@@ -41,15 +41,15 @@ struct CancelRetrieveRequest {
 
   bool operator!=(const CancelRetrieveRequest &rhs) const;
 
-  cta::common::dataStructures::UserIdentity requester;
+  UserIdentity requester;
   uint64_t archiveFileID;
   std::string dstURL;
-  cta::common::dataStructures::DRData drData;
+  DRData drData;
 
 }; // struct CancelRetrieveRequest
 
+std::ostream &operator<<(std::ostream &os, const CancelRetrieveRequest &obj);
+
 } // namespace dataStructures
 } // namespace common
 } // namespace cta
-
-std::ostream &operator<<(std::ostream &os, const cta::common::dataStructures::CancelRetrieveRequest &obj);
diff --git a/common/dataStructures/DRData.cpp b/common/dataStructures/DRData.cpp
index 9c0b98f2d8..1420e56779 100644
--- a/common/dataStructures/DRData.cpp
+++ b/common/dataStructures/DRData.cpp
@@ -20,15 +20,19 @@
 #include "common/dataStructures/utils.hpp"
 #include "common/exception/Exception.hpp"
 
+namespace cta {
+namespace common {
+namespace dataStructures {
+
 //------------------------------------------------------------------------------
 // constructor
 //------------------------------------------------------------------------------
-cta::common::dataStructures::DRData::DRData() {}
+DRData::DRData() {}
 
 //------------------------------------------------------------------------------
 // operator==
 //------------------------------------------------------------------------------
-bool cta::common::dataStructures::DRData::operator==(const DRData &rhs) const {
+bool DRData::operator==(const DRData &rhs) const {
   return drPath==rhs.drPath
       && drOwner==rhs.drOwner
       && drGroup==rhs.drGroup
@@ -38,14 +42,14 @@ bool cta::common::dataStructures::DRData::operator==(const DRData &rhs) const {
 //------------------------------------------------------------------------------
 // operator!=
 //------------------------------------------------------------------------------
-bool cta::common::dataStructures::DRData::operator!=(const DRData &rhs) const {
+bool DRData::operator!=(const DRData &rhs) const {
   return !operator==(rhs);
 }
 
 //------------------------------------------------------------------------------
 // operator<<
 //------------------------------------------------------------------------------
-std::ostream &operator<<(std::ostream &os, const cta::common::dataStructures::DRData &obj) {
+std::ostream &operator<<(std::ostream &os, const DRData &obj) {
   os << "(drPath=" << obj.drPath
      << " drOwner=" << obj.drOwner
      << " drGroup=" << obj.drGroup
@@ -53,3 +57,6 @@ std::ostream &operator<<(std::ostream &os, const cta::common::dataStructures::DR
   return os;
 }
 
+} // namespace dataStructures
+} // namespace common
+} // namespace cta
diff --git a/common/dataStructures/DRData.hpp b/common/dataStructures/DRData.hpp
index d3d3ca88ca..4fe7a63f7a 100644
--- a/common/dataStructures/DRData.hpp
+++ b/common/dataStructures/DRData.hpp
@@ -47,8 +47,8 @@ struct DRData {
 
 }; // struct DRData
 
+std::ostream &operator<<(std::ostream &os, const DRData &obj);
+
 } // namespace dataStructures
 } // namespace common
 } // namespace cta
-
-std::ostream &operator<<(std::ostream &os, const cta::common::dataStructures::DRData &obj);
diff --git a/common/dataStructures/Dedication.cpp b/common/dataStructures/Dedication.cpp
index f24169b542..f055bb923d 100644
--- a/common/dataStructures/Dedication.cpp
+++ b/common/dataStructures/Dedication.cpp
@@ -20,17 +20,21 @@
 #include "common/dataStructures/utils.hpp"
 #include "common/exception/Exception.hpp"
 
+namespace cta {
+namespace common {
+namespace dataStructures {
+
 //------------------------------------------------------------------------------
 // constructor
 //------------------------------------------------------------------------------
-cta::common::dataStructures::Dedication::Dedication():
+Dedication::Dedication():
   fromTimestamp(0),
   untilTimestamp(0) {}
 
 //------------------------------------------------------------------------------
 // operator==
 //------------------------------------------------------------------------------
-bool cta::common::dataStructures::Dedication::operator==(const Dedication &rhs) const {
+bool Dedication::operator==(const Dedication &rhs) const {
   return driveName==rhs.driveName
       && dedicationType==rhs.dedicationType
       && tag==rhs.tag
@@ -45,14 +49,14 @@ bool cta::common::dataStructures::Dedication::operator==(const Dedication &rhs)
 //------------------------------------------------------------------------------
 // operator!=
 //------------------------------------------------------------------------------
-bool cta::common::dataStructures::Dedication::operator!=(const Dedication &rhs) const {
+bool Dedication::operator!=(const Dedication &rhs) const {
   return !operator==(rhs);
 }
 
 //------------------------------------------------------------------------------
 // operator<<
 //------------------------------------------------------------------------------
-std::ostream &operator<<(std::ostream &os, const cta::common::dataStructures::Dedication &obj) {
+std::ostream &operator<<(std::ostream &os, const Dedication &obj) {
   os << "(driveName=" << obj.driveName
      << " dedicationType=" << obj.dedicationType
      << " tag=" << obj.tag
@@ -65,3 +69,6 @@ std::ostream &operator<<(std::ostream &os, const cta::common::dataStructures::De
   return os;
 }
 
+} // namespace dataStructures
+} // namespace common
+} // namespace cta
diff --git a/common/dataStructures/Dedication.hpp b/common/dataStructures/Dedication.hpp
index 167a144b87..c40d00ce5f 100644
--- a/common/dataStructures/Dedication.hpp
+++ b/common/dataStructures/Dedication.hpp
@@ -42,19 +42,19 @@ struct Dedication {
   bool operator!=(const Dedication &rhs) const;
 
   std::string driveName;
-  cta::common::dataStructures::DedicationType dedicationType;
+  DedicationType dedicationType;
   std::string tag;
   std::string vid;
   uint64_t fromTimestamp;
   uint64_t untilTimestamp;
-  cta::common::dataStructures::EntryLog creationLog;
-  cta::common::dataStructures::EntryLog lastModificationLog;
+  EntryLog creationLog;
+  EntryLog lastModificationLog;
   std::string comment;
 
 }; // struct Dedication
 
+std::ostream &operator<<(std::ostream &os, const Dedication &obj);
+
 } // namespace dataStructures
 } // namespace common
 } // namespace cta
-
-std::ostream &operator<<(std::ostream &os, const cta::common::dataStructures::Dedication &obj);
diff --git a/common/dataStructures/DeleteArchiveRequest.cpp b/common/dataStructures/DeleteArchiveRequest.cpp
index d3c47ff836..034f554bae 100644
--- a/common/dataStructures/DeleteArchiveRequest.cpp
+++ b/common/dataStructures/DeleteArchiveRequest.cpp
@@ -20,16 +20,20 @@
 #include "common/dataStructures/utils.hpp"
 #include "common/exception/Exception.hpp"
 
+namespace cta {
+namespace common {
+namespace dataStructures {
+
 //------------------------------------------------------------------------------
 // constructor
 //------------------------------------------------------------------------------
-cta::common::dataStructures::DeleteArchiveRequest::DeleteArchiveRequest():
+DeleteArchiveRequest::DeleteArchiveRequest():
   archiveFileID(0) {}
 
 //------------------------------------------------------------------------------
 // operator==
 //------------------------------------------------------------------------------
-bool cta::common::dataStructures::DeleteArchiveRequest::operator==(const DeleteArchiveRequest &rhs) const {
+bool DeleteArchiveRequest::operator==(const DeleteArchiveRequest &rhs) const {
   return requester==rhs.requester
       && archiveFileID==rhs.archiveFileID;
 }
@@ -37,16 +41,19 @@ bool cta::common::dataStructures::DeleteArchiveRequest::operator==(const DeleteA
 //------------------------------------------------------------------------------
 // operator!=
 //------------------------------------------------------------------------------
-bool cta::common::dataStructures::DeleteArchiveRequest::operator!=(const DeleteArchiveRequest &rhs) const {
+bool DeleteArchiveRequest::operator!=(const DeleteArchiveRequest &rhs) const {
   return !operator==(rhs);
 }
 
 //------------------------------------------------------------------------------
 // operator<<
 //------------------------------------------------------------------------------
-std::ostream &operator<<(std::ostream &os, const cta::common::dataStructures::DeleteArchiveRequest &obj) {
+std::ostream &operator<<(std::ostream &os, const DeleteArchiveRequest &obj) {
   os << "(requester=" << obj.requester
      << " archiveFileID=" << obj.archiveFileID << ")";
   return os;
 }
 
+} // namespace dataStructures
+} // namespace common
+} // namespace cta
diff --git a/common/dataStructures/DeleteArchiveRequest.hpp b/common/dataStructures/DeleteArchiveRequest.hpp
index f44d1ca909..fd0730d20c 100644
--- a/common/dataStructures/DeleteArchiveRequest.hpp
+++ b/common/dataStructures/DeleteArchiveRequest.hpp
@@ -41,13 +41,13 @@ struct DeleteArchiveRequest {
 
   bool operator!=(const DeleteArchiveRequest &rhs) const;
 
-  cta::common::dataStructures::UserIdentity requester;
+  UserIdentity requester;
   uint64_t archiveFileID;
 
 }; // struct DeleteArchiveRequest
 
+std::ostream &operator<<(std::ostream &os, const DeleteArchiveRequest &obj);
+
 } // namespace dataStructures
 } // namespace common
 } // namespace cta
-
-std::ostream &operator<<(std::ostream &os, const cta::common::dataStructures::DeleteArchiveRequest &obj);
diff --git a/common/dataStructures/DriveState.cpp b/common/dataStructures/DriveState.cpp
index 66075f9eb0..225ba6efbc 100644
--- a/common/dataStructures/DriveState.cpp
+++ b/common/dataStructures/DriveState.cpp
@@ -20,10 +20,14 @@
 #include "common/dataStructures/utils.hpp"
 #include "common/exception/Exception.hpp"
 
+namespace cta {
+namespace common {
+namespace dataStructures {
+
 //------------------------------------------------------------------------------
 // constructor
 //------------------------------------------------------------------------------
-cta::common::dataStructures::DriveState::DriveState():
+DriveState::DriveState():
   sessionId(0),
   bytesTransferedInSession(0),
   filesTransferedInSession(0),
@@ -34,7 +38,7 @@ cta::common::dataStructures::DriveState::DriveState():
 //------------------------------------------------------------------------------
 // operator==
 //------------------------------------------------------------------------------
-bool cta::common::dataStructures::DriveState::operator==(const DriveState &rhs) const {
+bool DriveState::operator==(const DriveState &rhs) const {
   return name==rhs.name
       && host==rhs.host
       && logicalLibrary==rhs.logicalLibrary
@@ -53,14 +57,14 @@ bool cta::common::dataStructures::DriveState::operator==(const DriveState &rhs)
 //------------------------------------------------------------------------------
 // operator!=
 //------------------------------------------------------------------------------
-bool cta::common::dataStructures::DriveState::operator!=(const DriveState &rhs) const {
+bool DriveState::operator!=(const DriveState &rhs) const {
   return !operator==(rhs);
 }
 
 //------------------------------------------------------------------------------
 // operator<<
 //------------------------------------------------------------------------------
-std::ostream &operator<<(std::ostream &os, const cta::common::dataStructures::DriveState &obj) {
+std::ostream &operator<<(std::ostream &os, const DriveState &obj) {
   os << "(name=" << obj.name
      << " host=" << obj.host
      << " logicalLibrary=" << obj.logicalLibrary
@@ -77,3 +81,6 @@ std::ostream &operator<<(std::ostream &os, const cta::common::dataStructures::Dr
   return os;
 }
 
+} // namespace dataStructures
+} // namespace common
+} // namespace cta
diff --git a/common/dataStructures/DriveState.hpp b/common/dataStructures/DriveState.hpp
index 14d4de38f3..75843f806e 100644
--- a/common/dataStructures/DriveState.hpp
+++ b/common/dataStructures/DriveState.hpp
@@ -51,15 +51,15 @@ struct DriveState {
   uint64_t latestBandwidth;
   time_t sessionStartTime;
   time_t currentStateStartTime;
-  cta::common::dataStructures::MountType mountType;
-  cta::common::dataStructures::DriveStatus status;
+  MountType mountType;
+  DriveStatus status;
   std::string currentVid;
   std::string currentTapePool;
 
 }; // struct DriveState
 
+std::ostream &operator<<(std::ostream &os, const DriveState &obj);
+
 } // namespace dataStructures
 } // namespace common
 } // namespace cta
-
-std::ostream &operator<<(std::ostream &os, const cta::common::dataStructures::DriveState &obj);
diff --git a/common/dataStructures/EntryLog.cpp b/common/dataStructures/EntryLog.cpp
index 1d79f23af9..4898cdfe71 100644
--- a/common/dataStructures/EntryLog.cpp
+++ b/common/dataStructures/EntryLog.cpp
@@ -20,16 +20,20 @@
 #include "common/dataStructures/utils.hpp"
 #include "common/exception/Exception.hpp"
 
+namespace cta {
+namespace common {
+namespace dataStructures {
+
 //------------------------------------------------------------------------------
 // constructor
 //------------------------------------------------------------------------------
-cta::common::dataStructures::EntryLog::EntryLog():
+EntryLog::EntryLog():
   time(0) {}
 
 //------------------------------------------------------------------------------
 // operator==
 //------------------------------------------------------------------------------
-bool cta::common::dataStructures::EntryLog::operator==(const EntryLog &rhs) const {
+bool EntryLog::operator==(const EntryLog &rhs) const {
   return user==rhs.user
       && host==rhs.host
       && time==rhs.time;
@@ -38,17 +42,20 @@ bool cta::common::dataStructures::EntryLog::operator==(const EntryLog &rhs) cons
 //------------------------------------------------------------------------------
 // operator!=
 //------------------------------------------------------------------------------
-bool cta::common::dataStructures::EntryLog::operator!=(const EntryLog &rhs) const {
+bool EntryLog::operator!=(const EntryLog &rhs) const {
   return !operator==(rhs);
 }
 
 //------------------------------------------------------------------------------
 // operator<<
 //------------------------------------------------------------------------------
-std::ostream &operator<<(std::ostream &os, const cta::common::dataStructures::EntryLog &obj) {
+std::ostream &operator<<(std::ostream &os, const EntryLog &obj) {
   os << "(user=" << obj.user
      << " host=" << obj.host
      << " time=" << obj.time << ")";
   return os;
 }
 
+} // namespace dataStructures
+} // namespace common
+} // namespace cta
diff --git a/common/dataStructures/EntryLog.hpp b/common/dataStructures/EntryLog.hpp
index 087bfbb061..7f5510a32b 100644
--- a/common/dataStructures/EntryLog.hpp
+++ b/common/dataStructures/EntryLog.hpp
@@ -41,14 +41,14 @@ struct EntryLog {
 
   bool operator!=(const EntryLog &rhs) const;
 
-  cta::common::dataStructures::UserIdentity user;
+  UserIdentity user;
   std::string host;
   time_t time;
 
 }; // struct EntryLog
 
+std::ostream &operator<<(std::ostream &os, const EntryLog &obj);
+
 } // namespace dataStructures
 } // namespace common
 } // namespace cta
-
-std::ostream &operator<<(std::ostream &os, const cta::common::dataStructures::EntryLog &obj);
diff --git a/common/dataStructures/ListStorageClassRequest.cpp b/common/dataStructures/ListStorageClassRequest.cpp
index 08e813301a..dde09ca0f1 100644
--- a/common/dataStructures/ListStorageClassRequest.cpp
+++ b/common/dataStructures/ListStorageClassRequest.cpp
@@ -20,30 +20,37 @@
 #include "common/dataStructures/utils.hpp"
 #include "common/exception/Exception.hpp"
 
+namespace cta {
+namespace common {
+namespace dataStructures {
+
 //------------------------------------------------------------------------------
 // constructor
 //------------------------------------------------------------------------------
-cta::common::dataStructures::ListStorageClassRequest::ListStorageClassRequest() {}
+ListStorageClassRequest::ListStorageClassRequest() {}
 
 //------------------------------------------------------------------------------
 // operator==
 //------------------------------------------------------------------------------
-bool cta::common::dataStructures::ListStorageClassRequest::operator==(const ListStorageClassRequest &rhs) const {
+bool ListStorageClassRequest::operator==(const ListStorageClassRequest &rhs) const {
   return requester==rhs.requester;
 }
 
 //------------------------------------------------------------------------------
 // operator!=
 //------------------------------------------------------------------------------
-bool cta::common::dataStructures::ListStorageClassRequest::operator!=(const ListStorageClassRequest &rhs) const {
+bool ListStorageClassRequest::operator!=(const ListStorageClassRequest &rhs) const {
   return !operator==(rhs);
 }
 
 //------------------------------------------------------------------------------
 // operator<<
 //------------------------------------------------------------------------------
-std::ostream &operator<<(std::ostream &os, const cta::common::dataStructures::ListStorageClassRequest &obj) {
+std::ostream &operator<<(std::ostream &os, const ListStorageClassRequest &obj) {
   os << "(requester=" << obj.requester << ")";
   return os;
 }
 
+} // namespace dataStructures
+} // namespace common
+} // namespace cta
diff --git a/common/dataStructures/ListStorageClassRequest.hpp b/common/dataStructures/ListStorageClassRequest.hpp
index 859b3df75a..9bb3a01785 100644
--- a/common/dataStructures/ListStorageClassRequest.hpp
+++ b/common/dataStructures/ListStorageClassRequest.hpp
@@ -40,12 +40,12 @@ struct ListStorageClassRequest {
 
   bool operator!=(const ListStorageClassRequest &rhs) const;
 
-  cta::common::dataStructures::UserIdentity requester;
+  UserIdentity requester;
 
 }; // struct ListStorageClassRequest
 
+std::ostream &operator<<(std::ostream &os, const ListStorageClassRequest &obj);
+
 } // namespace dataStructures
 } // namespace common
 } // namespace cta
-
-std::ostream &operator<<(std::ostream &os, const cta::common::dataStructures::ListStorageClassRequest &obj);
diff --git a/common/dataStructures/LogicalLibrary.cpp b/common/dataStructures/LogicalLibrary.cpp
index 3b91cf67c8..1e6efaf6fb 100644
--- a/common/dataStructures/LogicalLibrary.cpp
+++ b/common/dataStructures/LogicalLibrary.cpp
@@ -20,15 +20,19 @@
 #include "common/dataStructures/utils.hpp"
 #include "common/exception/Exception.hpp"
 
+namespace cta {
+namespace common {
+namespace dataStructures {
+
 //------------------------------------------------------------------------------
 // constructor
 //------------------------------------------------------------------------------
-cta::common::dataStructures::LogicalLibrary::LogicalLibrary() {}
+LogicalLibrary::LogicalLibrary() {}
 
 //------------------------------------------------------------------------------
 // operator==
 //------------------------------------------------------------------------------
-bool cta::common::dataStructures::LogicalLibrary::operator==(const LogicalLibrary &rhs) const {
+bool LogicalLibrary::operator==(const LogicalLibrary &rhs) const {
   return name==rhs.name
       && creationLog==rhs.creationLog
       && lastModificationLog==rhs.lastModificationLog
@@ -38,14 +42,14 @@ bool cta::common::dataStructures::LogicalLibrary::operator==(const LogicalLibrar
 //------------------------------------------------------------------------------
 // operator!=
 //------------------------------------------------------------------------------
-bool cta::common::dataStructures::LogicalLibrary::operator!=(const LogicalLibrary &rhs) const {
+bool LogicalLibrary::operator!=(const LogicalLibrary &rhs) const {
   return !operator==(rhs);
 }
 
 //------------------------------------------------------------------------------
 // operator<<
 //------------------------------------------------------------------------------
-std::ostream &operator<<(std::ostream &os, const cta::common::dataStructures::LogicalLibrary &obj) {
+std::ostream &operator<<(std::ostream &os, const LogicalLibrary &obj) {
   os << "(name=" << obj.name
      << " creationLog=" << obj.creationLog
      << " lastModificationLog=" << obj.lastModificationLog
@@ -53,3 +57,6 @@ std::ostream &operator<<(std::ostream &os, const cta::common::dataStructures::Lo
   return os;
 }
 
+} // namespace dataStructures
+} // namespace common
+} // namespace cta
diff --git a/common/dataStructures/LogicalLibrary.hpp b/common/dataStructures/LogicalLibrary.hpp
index 856e09242c..8ab20e4334 100644
--- a/common/dataStructures/LogicalLibrary.hpp
+++ b/common/dataStructures/LogicalLibrary.hpp
@@ -42,14 +42,14 @@ struct LogicalLibrary {
   bool operator!=(const LogicalLibrary &rhs) const;
 
   std::string name;
-  cta::common::dataStructures::EntryLog creationLog;
-  cta::common::dataStructures::EntryLog lastModificationLog;
+  EntryLog creationLog;
+  EntryLog lastModificationLog;
   std::string comment;
 
 }; // struct LogicalLibrary
 
+std::ostream &operator<<(std::ostream &os, const LogicalLibrary &obj);
+
 } // namespace dataStructures
 } // namespace common
 } // namespace cta
-
-std::ostream &operator<<(std::ostream &os, const cta::common::dataStructures::LogicalLibrary &obj);
diff --git a/common/dataStructures/MountPolicy.cpp b/common/dataStructures/MountPolicy.cpp
index b23563872d..60edd2a279 100644
--- a/common/dataStructures/MountPolicy.cpp
+++ b/common/dataStructures/MountPolicy.cpp
@@ -20,10 +20,14 @@
 #include "common/dataStructures/utils.hpp"
 #include "common/exception/Exception.hpp"
 
+namespace cta {
+namespace common {
+namespace dataStructures {
+
 //------------------------------------------------------------------------------
 // constructor
 //------------------------------------------------------------------------------
-cta::common::dataStructures::MountPolicy::MountPolicy():
+MountPolicy::MountPolicy():
   archive_priority(0),
   archive_minRequestAge(0),
   retrieve_priority(0),
@@ -33,7 +37,7 @@ cta::common::dataStructures::MountPolicy::MountPolicy():
 //------------------------------------------------------------------------------
 // operator==
 //------------------------------------------------------------------------------
-bool cta::common::dataStructures::MountPolicy::operator==(const MountPolicy &rhs) const {
+bool MountPolicy::operator==(const MountPolicy &rhs) const {
   return name==rhs.name
       && archive_priority==rhs.archive_priority
       && archive_minRequestAge==rhs.archive_minRequestAge
@@ -48,14 +52,14 @@ bool cta::common::dataStructures::MountPolicy::operator==(const MountPolicy &rhs
 //------------------------------------------------------------------------------
 // operator!=
 //------------------------------------------------------------------------------
-bool cta::common::dataStructures::MountPolicy::operator!=(const MountPolicy &rhs) const {
+bool MountPolicy::operator!=(const MountPolicy &rhs) const {
   return !operator==(rhs);
 }
 
 //------------------------------------------------------------------------------
 // operator<<
 //------------------------------------------------------------------------------
-std::ostream &operator<<(std::ostream &os, const cta::common::dataStructures::MountPolicy &obj) {
+std::ostream &operator<<(std::ostream &os, const MountPolicy &obj) {
   os << "(name=" << obj.name
      << " archive_priority=" << obj.archive_priority
      << " archive_minRequestAge=" << obj.archive_minRequestAge
@@ -68,3 +72,6 @@ std::ostream &operator<<(std::ostream &os, const cta::common::dataStructures::Mo
   return os;
 }
 
+} // namespace dataStructures
+} // namespace common
+} // namespace cta
diff --git a/common/dataStructures/MountPolicy.hpp b/common/dataStructures/MountPolicy.hpp
index 57710acc83..6233d599a2 100644
--- a/common/dataStructures/MountPolicy.hpp
+++ b/common/dataStructures/MountPolicy.hpp
@@ -46,14 +46,14 @@ struct MountPolicy {
   uint64_t retrieve_priority;
   uint64_t retrieve_minRequestAge;
   uint64_t maxDrivesAllowed;
-  cta::common::dataStructures::EntryLog creationLog;
-  cta::common::dataStructures::EntryLog lastModificationLog;
+  EntryLog creationLog;
+  EntryLog lastModificationLog;
   std::string comment;
 
 }; // struct MountPolicy
 
+std::ostream &operator<<(std::ostream &os, const MountPolicy &obj);
+
 } // namespace dataStructures
 } // namespace common
 } // namespace cta
-
-std::ostream &operator<<(std::ostream &os, const cta::common::dataStructures::MountPolicy &obj);
diff --git a/common/dataStructures/ReadTestResult.cpp b/common/dataStructures/ReadTestResult.cpp
index 1e0d2f7ee5..3a6041a9be 100644
--- a/common/dataStructures/ReadTestResult.cpp
+++ b/common/dataStructures/ReadTestResult.cpp
@@ -20,10 +20,14 @@
 #include "common/dataStructures/utils.hpp"
 #include "common/exception/Exception.hpp"
 
+namespace cta {
+namespace common {
+namespace dataStructures {
+
 //------------------------------------------------------------------------------
 // constructor
 //------------------------------------------------------------------------------
-cta::common::dataStructures::ReadTestResult::ReadTestResult():
+ReadTestResult::ReadTestResult():
   noOfFilesRead(0),
   totalBytesRead(0),
   totalFilesRead(0),
@@ -32,7 +36,7 @@ cta::common::dataStructures::ReadTestResult::ReadTestResult():
 //------------------------------------------------------------------------------
 // operator==
 //------------------------------------------------------------------------------
-bool cta::common::dataStructures::ReadTestResult::operator==(const ReadTestResult &rhs) const {
+bool ReadTestResult::operator==(const ReadTestResult &rhs) const {
   return driveName==rhs.driveName
       && vid==rhs.vid
       && noOfFilesRead==rhs.noOfFilesRead
@@ -46,14 +50,14 @@ bool cta::common::dataStructures::ReadTestResult::operator==(const ReadTestResul
 //------------------------------------------------------------------------------
 // operator!=
 //------------------------------------------------------------------------------
-bool cta::common::dataStructures::ReadTestResult::operator!=(const ReadTestResult &rhs) const {
+bool ReadTestResult::operator!=(const ReadTestResult &rhs) const {
   return !operator==(rhs);
 }
 
 //------------------------------------------------------------------------------
 // operator<<
 //------------------------------------------------------------------------------
-std::ostream &operator<<(std::ostream &os, const cta::common::dataStructures::ReadTestResult &obj) {
+std::ostream &operator<<(std::ostream &os, const ReadTestResult &obj) {
   os << "(driveName=" << obj.driveName
      << " vid=" << obj.vid
      << " noOfFilesRead=" << obj.noOfFilesRead
@@ -65,3 +69,6 @@ std::ostream &operator<<(std::ostream &os, const cta::common::dataStructures::Re
   return os;
 }
 
+} // namespace dataStructures
+} // namespace common
+} // namespace cta
diff --git a/common/dataStructures/ReadTestResult.hpp b/common/dataStructures/ReadTestResult.hpp
index 8f717bbb3a..edd33207e9 100644
--- a/common/dataStructures/ReadTestResult.hpp
+++ b/common/dataStructures/ReadTestResult.hpp
@@ -50,8 +50,8 @@ struct ReadTestResult {
 
 }; // struct ReadTestResult
 
+std::ostream &operator<<(std::ostream &os, const ReadTestResult &obj);
+
 } // namespace dataStructures
 } // namespace common
 } // namespace cta
-
-std::ostream &operator<<(std::ostream &os, const cta::common::dataStructures::ReadTestResult &obj);
diff --git a/common/dataStructures/RepackInfo.cpp b/common/dataStructures/RepackInfo.cpp
index b0f7b91150..5f42b702e3 100644
--- a/common/dataStructures/RepackInfo.cpp
+++ b/common/dataStructures/RepackInfo.cpp
@@ -20,10 +20,14 @@
 #include "common/dataStructures/utils.hpp"
 #include "common/exception/Exception.hpp"
 
+namespace cta {
+namespace common {
+namespace dataStructures {
+
 //------------------------------------------------------------------------------
 // constructor
 //------------------------------------------------------------------------------
-cta::common::dataStructures::RepackInfo::RepackInfo():
+RepackInfo::RepackInfo():
   totalFiles(0),
   totalSize(0),
   filesToRetrieve(0),
@@ -34,7 +38,7 @@ cta::common::dataStructures::RepackInfo::RepackInfo():
 //------------------------------------------------------------------------------
 // operator==
 //------------------------------------------------------------------------------
-bool cta::common::dataStructures::RepackInfo::operator==(const RepackInfo &rhs) const {
+bool RepackInfo::operator==(const RepackInfo &rhs) const {
   return vid==rhs.vid
       && tag==rhs.tag
       && totalFiles==rhs.totalFiles
@@ -52,14 +56,14 @@ bool cta::common::dataStructures::RepackInfo::operator==(const RepackInfo &rhs)
 //------------------------------------------------------------------------------
 // operator!=
 //------------------------------------------------------------------------------
-bool cta::common::dataStructures::RepackInfo::operator!=(const RepackInfo &rhs) const {
+bool RepackInfo::operator!=(const RepackInfo &rhs) const {
   return !operator==(rhs);
 }
 
 //------------------------------------------------------------------------------
 // operator<<
 //------------------------------------------------------------------------------
-std::ostream &operator<<(std::ostream &os, const cta::common::dataStructures::RepackInfo &obj) {
+std::ostream &operator<<(std::ostream &os, const RepackInfo &obj) {
   os << "(vid=" << obj.vid
      << " tag=" << obj.tag
      << " totalFiles=" << obj.totalFiles
@@ -75,3 +79,6 @@ std::ostream &operator<<(std::ostream &os, const cta::common::dataStructures::Re
   return os;
 }
 
+} // namespace dataStructures
+} // namespace common
+} // namespace cta
diff --git a/common/dataStructures/RepackInfo.hpp b/common/dataStructures/RepackInfo.hpp
index faa2fd4c98..ca97c8b751 100644
--- a/common/dataStructures/RepackInfo.hpp
+++ b/common/dataStructures/RepackInfo.hpp
@@ -49,15 +49,15 @@ struct RepackInfo {
   uint64_t filesToArchive;
   uint64_t filesFailed;
   uint64_t filesArchived;
-  cta::common::dataStructures::RepackType repackType;
+  RepackType repackType;
   std::string repackStatus;
   std::map<uint64_t,std::string> errors;
-  cta::common::dataStructures::EntryLog creationLog;
+  EntryLog creationLog;
 
 }; // struct RepackInfo
 
+std::ostream &operator<<(std::ostream &os, const RepackInfo &obj);
+
 } // namespace dataStructures
 } // namespace common
 } // namespace cta
-
-std::ostream &operator<<(std::ostream &os, const cta::common::dataStructures::RepackInfo &obj);
diff --git a/common/dataStructures/Requester.cpp b/common/dataStructures/Requester.cpp
index 106ae39472..c2a5ba17bd 100644
--- a/common/dataStructures/Requester.cpp
+++ b/common/dataStructures/Requester.cpp
@@ -20,15 +20,19 @@
 #include "common/dataStructures/utils.hpp"
 #include "common/exception/Exception.hpp"
 
+namespace cta {
+namespace common {
+namespace dataStructures {
+
 //------------------------------------------------------------------------------
 // constructor
 //------------------------------------------------------------------------------
-cta::common::dataStructures::Requester::Requester() {}
+Requester::Requester() {}
 
 //------------------------------------------------------------------------------
 // operator==
 //------------------------------------------------------------------------------
-bool cta::common::dataStructures::Requester::operator==(const Requester &rhs) const {
+bool Requester::operator==(const Requester &rhs) const {
   return name==rhs.name
       && group==rhs.group
       && mountPolicy==rhs.mountPolicy
@@ -40,14 +44,14 @@ bool cta::common::dataStructures::Requester::operator==(const Requester &rhs) co
 //------------------------------------------------------------------------------
 // operator!=
 //------------------------------------------------------------------------------
-bool cta::common::dataStructures::Requester::operator!=(const Requester &rhs) const {
+bool Requester::operator!=(const Requester &rhs) const {
   return !operator==(rhs);
 }
 
 //------------------------------------------------------------------------------
 // operator<<
 //------------------------------------------------------------------------------
-std::ostream &operator<<(std::ostream &os, const cta::common::dataStructures::Requester &obj) {
+std::ostream &operator<<(std::ostream &os, const Requester &obj) {
   os << "(name=" << obj.name
      << " group=" << obj.group
      << " mountPolicy=" << obj.mountPolicy
@@ -57,3 +61,6 @@ std::ostream &operator<<(std::ostream &os, const cta::common::dataStructures::Re
   return os;
 }
 
+} // namespace dataStructures
+} // namespace common
+} // namespace cta
diff --git a/common/dataStructures/Requester.hpp b/common/dataStructures/Requester.hpp
index dc5b36f1d3..eb41cc1bfa 100644
--- a/common/dataStructures/Requester.hpp
+++ b/common/dataStructures/Requester.hpp
@@ -46,14 +46,14 @@ struct Requester {
   std::string name;
   std::string group;
   std::string mountPolicy;
-  cta::common::dataStructures::EntryLog creationLog;
-  cta::common::dataStructures::EntryLog lastModificationLog;
+  EntryLog creationLog;
+  EntryLog lastModificationLog;
   std::string comment;
 
 }; // struct Requester
 
+std::ostream &operator<<(std::ostream &os, const Requester &obj);
+
 } // namespace dataStructures
 } // namespace common
 } // namespace cta
-
-std::ostream &operator<<(std::ostream &os, const cta::common::dataStructures::Requester &obj);
diff --git a/common/dataStructures/RetrieveJob.cpp b/common/dataStructures/RetrieveJob.cpp
index 5d93e16ef7..6c58a7d046 100644
--- a/common/dataStructures/RetrieveJob.cpp
+++ b/common/dataStructures/RetrieveJob.cpp
@@ -20,15 +20,19 @@
 #include "common/dataStructures/utils.hpp"
 #include "common/exception/Exception.hpp"
 
+namespace cta {
+namespace common {
+namespace dataStructures {
+
 //------------------------------------------------------------------------------
 // constructor
 //------------------------------------------------------------------------------
-cta::common::dataStructures::RetrieveJob::RetrieveJob() {}
+RetrieveJob::RetrieveJob() {}
 
 //------------------------------------------------------------------------------
 // operator==
 //------------------------------------------------------------------------------
-bool cta::common::dataStructures::RetrieveJob::operator==(const RetrieveJob &rhs) const {
+bool RetrieveJob::operator==(const RetrieveJob &rhs) const {
   return request==rhs.request
       && tapeCopies==rhs.tapeCopies;
 }
@@ -36,16 +40,19 @@ bool cta::common::dataStructures::RetrieveJob::operator==(const RetrieveJob &rhs
 //------------------------------------------------------------------------------
 // operator!=
 //------------------------------------------------------------------------------
-bool cta::common::dataStructures::RetrieveJob::operator!=(const RetrieveJob &rhs) const {
+bool RetrieveJob::operator!=(const RetrieveJob &rhs) const {
   return !operator==(rhs);
 }
 
 //------------------------------------------------------------------------------
 // operator<<
 //------------------------------------------------------------------------------
-std::ostream &operator<<(std::ostream &os, const cta::common::dataStructures::RetrieveJob &obj) {
+std::ostream &operator<<(std::ostream &os, const RetrieveJob &obj) {
   os << "(request=" << obj.request
      << " tapeCopies=" << obj.tapeCopies << ")";
   return os;
 }
 
+} // namespace dataStructures
+} // namespace common
+} // namespace cta
diff --git a/common/dataStructures/RetrieveJob.hpp b/common/dataStructures/RetrieveJob.hpp
index 7a965eb058..b1eec02daf 100644
--- a/common/dataStructures/RetrieveJob.hpp
+++ b/common/dataStructures/RetrieveJob.hpp
@@ -42,13 +42,13 @@ struct RetrieveJob {
 
   bool operator!=(const RetrieveJob &rhs) const;
 
-  cta::common::dataStructures::RetrieveRequest request;
-  std::map<std::string,std::pair<uint64_t,cta::common::dataStructures::TapeFile>> tapeCopies;
+  RetrieveRequest request;
+  std::map<std::string,std::pair<uint64_t,TapeFile>> tapeCopies;
 
 }; // struct RetrieveJob
 
+std::ostream &operator<<(std::ostream &os, const RetrieveJob &obj);
+
 } // namespace dataStructures
 } // namespace common
 } // namespace cta
-
-std::ostream &operator<<(std::ostream &os, const cta::common::dataStructures::RetrieveJob &obj);
diff --git a/common/dataStructures/RetrieveRequest.cpp b/common/dataStructures/RetrieveRequest.cpp
index fba6a15e1d..e8c3d03729 100644
--- a/common/dataStructures/RetrieveRequest.cpp
+++ b/common/dataStructures/RetrieveRequest.cpp
@@ -20,17 +20,21 @@
 #include "common/dataStructures/utils.hpp"
 #include "common/exception/Exception.hpp"
 
+namespace cta {
+namespace common {
+namespace dataStructures {
+
 //------------------------------------------------------------------------------
 // constructor
 //------------------------------------------------------------------------------
-cta::common::dataStructures::RetrieveRequest::RetrieveRequest():
+RetrieveRequest::RetrieveRequest():
   archiveFileID(0),
   diskpoolThroughput(0) {}
 
 //------------------------------------------------------------------------------
 // operator==
 //------------------------------------------------------------------------------
-bool cta::common::dataStructures::RetrieveRequest::operator==(const RetrieveRequest &rhs) const {
+bool RetrieveRequest::operator==(const RetrieveRequest &rhs) const {
   return requester==rhs.requester
       && archiveFileID==rhs.archiveFileID
       && dstURL==rhs.dstURL
@@ -43,14 +47,14 @@ bool cta::common::dataStructures::RetrieveRequest::operator==(const RetrieveRequ
 //------------------------------------------------------------------------------
 // operator!=
 //------------------------------------------------------------------------------
-bool cta::common::dataStructures::RetrieveRequest::operator!=(const RetrieveRequest &rhs) const {
+bool RetrieveRequest::operator!=(const RetrieveRequest &rhs) const {
   return !operator==(rhs);
 }
 
 //------------------------------------------------------------------------------
 // operator<<
 //------------------------------------------------------------------------------
-std::ostream &operator<<(std::ostream &os, const cta::common::dataStructures::RetrieveRequest &obj) {
+std::ostream &operator<<(std::ostream &os, const RetrieveRequest &obj) {
   os << "(requester=" << obj.requester
      << " archiveFileID=" << obj.archiveFileID
      << " dstURL=" << obj.dstURL
@@ -61,3 +65,6 @@ std::ostream &operator<<(std::ostream &os, const cta::common::dataStructures::Re
   return os;
 }
 
+} // namespace dataStructures
+} // namespace common
+} // namespace cta
diff --git a/common/dataStructures/RetrieveRequest.hpp b/common/dataStructures/RetrieveRequest.hpp
index d9ab77cc77..91e29e6dd5 100644
--- a/common/dataStructures/RetrieveRequest.hpp
+++ b/common/dataStructures/RetrieveRequest.hpp
@@ -42,18 +42,18 @@ struct RetrieveRequest {
 
   bool operator!=(const RetrieveRequest &rhs) const;
 
-  cta::common::dataStructures::UserIdentity requester;
+  UserIdentity requester;
   uint64_t archiveFileID;
   std::string dstURL;
-  cta::common::dataStructures::DRData drData;
+  DRData drData;
   std::string diskpoolName;
   uint64_t diskpoolThroughput;
-  cta::common::dataStructures::EntryLog creationLog;
+  EntryLog creationLog;
 
 }; // struct RetrieveRequest
 
+std::ostream &operator<<(std::ostream &os, const RetrieveRequest &obj);
+
 } // namespace dataStructures
 } // namespace common
 } // namespace cta
-
-std::ostream &operator<<(std::ostream &os, const cta::common::dataStructures::RetrieveRequest &obj);
diff --git a/common/dataStructures/SecurityIdentity.cpp b/common/dataStructures/SecurityIdentity.cpp
index 90123035d7..e677e29fdc 100644
--- a/common/dataStructures/SecurityIdentity.cpp
+++ b/common/dataStructures/SecurityIdentity.cpp
@@ -20,15 +20,19 @@
 #include "common/dataStructures/utils.hpp"
 #include "common/exception/Exception.hpp"
 
+namespace cta {
+namespace common {
+namespace dataStructures {
+
 //------------------------------------------------------------------------------
 // constructor
 //------------------------------------------------------------------------------
-cta::common::dataStructures::SecurityIdentity::SecurityIdentity() {}
+SecurityIdentity::SecurityIdentity() {}
 
 //------------------------------------------------------------------------------
 // operator==
 //------------------------------------------------------------------------------
-bool cta::common::dataStructures::SecurityIdentity::operator==(const SecurityIdentity &rhs) const {
+bool SecurityIdentity::operator==(const SecurityIdentity &rhs) const {
   return user==rhs.user
       && host==rhs.host;
 }
@@ -36,16 +40,19 @@ bool cta::common::dataStructures::SecurityIdentity::operator==(const SecurityIde
 //------------------------------------------------------------------------------
 // operator!=
 //------------------------------------------------------------------------------
-bool cta::common::dataStructures::SecurityIdentity::operator!=(const SecurityIdentity &rhs) const {
+bool SecurityIdentity::operator!=(const SecurityIdentity &rhs) const {
   return !operator==(rhs);
 }
 
 //------------------------------------------------------------------------------
 // operator<<
 //------------------------------------------------------------------------------
-std::ostream &operator<<(std::ostream &os, const cta::common::dataStructures::SecurityIdentity &obj) {
+std::ostream &operator<<(std::ostream &os, const SecurityIdentity &obj) {
   os << "(user=" << obj.user
      << " host=" << obj.host << ")";
   return os;
 }
 
+} // namespace dataStructures
+} // namespace common
+} // namespace cta
diff --git a/common/dataStructures/SecurityIdentity.hpp b/common/dataStructures/SecurityIdentity.hpp
index a9be94017a..9c7b0ffcf6 100644
--- a/common/dataStructures/SecurityIdentity.hpp
+++ b/common/dataStructures/SecurityIdentity.hpp
@@ -41,13 +41,13 @@ struct SecurityIdentity {
 
   bool operator!=(const SecurityIdentity &rhs) const;
 
-  cta::common::dataStructures::UserIdentity user;
+  UserIdentity user;
   std::string host;
 
 }; // struct SecurityIdentity
 
+std::ostream &operator<<(std::ostream &os, const SecurityIdentity &obj);
+
 } // namespace dataStructures
 } // namespace common
 } // namespace cta
-
-std::ostream &operator<<(std::ostream &os, const cta::common::dataStructures::SecurityIdentity &obj);
diff --git a/common/dataStructures/StorageClass.cpp b/common/dataStructures/StorageClass.cpp
index 7aa07684ff..1c3a41e5bc 100644
--- a/common/dataStructures/StorageClass.cpp
+++ b/common/dataStructures/StorageClass.cpp
@@ -20,16 +20,20 @@
 #include "common/dataStructures/utils.hpp"
 #include "common/exception/Exception.hpp"
 
+namespace cta {
+namespace common {
+namespace dataStructures {
+
 //------------------------------------------------------------------------------
 // constructor
 //------------------------------------------------------------------------------
-cta::common::dataStructures::StorageClass::StorageClass():
+StorageClass::StorageClass():
   nbCopies(0) {}
 
 //------------------------------------------------------------------------------
 // operator==
 //------------------------------------------------------------------------------
-bool cta::common::dataStructures::StorageClass::operator==(const StorageClass &rhs) const {
+bool StorageClass::operator==(const StorageClass &rhs) const {
   return name==rhs.name
       && nbCopies==rhs.nbCopies
       && creationLog==rhs.creationLog
@@ -40,14 +44,14 @@ bool cta::common::dataStructures::StorageClass::operator==(const StorageClass &r
 //------------------------------------------------------------------------------
 // operator!=
 //------------------------------------------------------------------------------
-bool cta::common::dataStructures::StorageClass::operator!=(const StorageClass &rhs) const {
+bool StorageClass::operator!=(const StorageClass &rhs) const {
   return !operator==(rhs);
 }
 
 //------------------------------------------------------------------------------
 // operator<<
 //------------------------------------------------------------------------------
-std::ostream &operator<<(std::ostream &os, const cta::common::dataStructures::StorageClass &obj) {
+std::ostream &operator<<(std::ostream &os, const StorageClass &obj) {
   os << "(name=" << obj.name
      << " nbCopies=" << obj.nbCopies
      << " creationLog=" << obj.creationLog
@@ -56,3 +60,6 @@ std::ostream &operator<<(std::ostream &os, const cta::common::dataStructures::St
   return os;
 }
 
+} // namespace dataStructures
+} // namespace common
+} // namespace cta
diff --git a/common/dataStructures/StorageClass.hpp b/common/dataStructures/StorageClass.hpp
index f34e148623..a8a6bd5c63 100644
--- a/common/dataStructures/StorageClass.hpp
+++ b/common/dataStructures/StorageClass.hpp
@@ -44,14 +44,14 @@ struct StorageClass {
 
   std::string name;
   uint64_t nbCopies;
-  cta::common::dataStructures::EntryLog creationLog;
-  cta::common::dataStructures::EntryLog lastModificationLog;
+  EntryLog creationLog;
+  EntryLog lastModificationLog;
   std::string comment;
 
 }; // struct StorageClass
 
+std::ostream &operator<<(std::ostream &os, const StorageClass &obj);
+
 } // namespace dataStructures
 } // namespace common
 } // namespace cta
-
-std::ostream &operator<<(std::ostream &os, const cta::common::dataStructures::StorageClass &obj);
diff --git a/common/dataStructures/Tape.cpp b/common/dataStructures/Tape.cpp
index ed7abfee38..4dd4e548b3 100644
--- a/common/dataStructures/Tape.cpp
+++ b/common/dataStructures/Tape.cpp
@@ -20,10 +20,14 @@
 #include "common/dataStructures/utils.hpp"
 #include "common/exception/Exception.hpp"
 
+namespace cta {
+namespace common {
+namespace dataStructures {
+
 //------------------------------------------------------------------------------
 // constructor
 //------------------------------------------------------------------------------
-cta::common::dataStructures::Tape::Tape():
+Tape::Tape():
   lastFSeq(0),
   capacityInBytes(0),
   dataOnTapeInBytes(0) {}
@@ -31,7 +35,7 @@ cta::common::dataStructures::Tape::Tape():
 //------------------------------------------------------------------------------
 // operator==
 //------------------------------------------------------------------------------
-bool cta::common::dataStructures::Tape::operator==(const Tape &rhs) const {
+bool Tape::operator==(const Tape &rhs) const {
   return vid==rhs.vid
       && lastFSeq==rhs.lastFSeq
       && logicalLibraryName==rhs.logicalLibraryName
@@ -54,14 +58,14 @@ bool cta::common::dataStructures::Tape::operator==(const Tape &rhs) const {
 //------------------------------------------------------------------------------
 // operator!=
 //------------------------------------------------------------------------------
-bool cta::common::dataStructures::Tape::operator!=(const Tape &rhs) const {
+bool Tape::operator!=(const Tape &rhs) const {
   return !operator==(rhs);
 }
 
 //------------------------------------------------------------------------------
 // operator<<
 //------------------------------------------------------------------------------
-std::ostream &operator<<(std::ostream &os, const cta::common::dataStructures::Tape &obj) {
+std::ostream &operator<<(std::ostream &os, const Tape &obj) {
   os << "(vid=" << obj.vid
      << " lastFSeq=" << obj.lastFSeq
      << " logicalLibraryName=" << obj.logicalLibraryName
@@ -82,3 +86,6 @@ std::ostream &operator<<(std::ostream &os, const cta::common::dataStructures::Ta
   return os;
 }
 
+} // namespace dataStructures
+} // namespace common
+} // namespace cta
diff --git a/common/dataStructures/Tape.hpp b/common/dataStructures/Tape.hpp
index 157f7b96e8..761970bb0d 100644
--- a/common/dataStructures/Tape.hpp
+++ b/common/dataStructures/Tape.hpp
@@ -52,17 +52,17 @@ struct Tape {
   bool busy;
   bool full;
   bool disabled;
-  cta::common::dataStructures::EntryLog creationLog;
-  cta::common::dataStructures::EntryLog lastModificationLog;
+  EntryLog creationLog;
+  EntryLog lastModificationLog;
   std::string comment;
-  cta::common::dataStructures::TapeLog labelLog;
-  cta::common::dataStructures::TapeLog lastWriteLog;
-  cta::common::dataStructures::TapeLog lastReadLog;
+  TapeLog labelLog;
+  TapeLog lastWriteLog;
+  TapeLog lastReadLog;
 
 }; // struct Tape
 
+std::ostream &operator<<(std::ostream &os, const Tape &obj);
+
 } // namespace dataStructures
 } // namespace common
 } // namespace cta
-
-std::ostream &operator<<(std::ostream &os, const cta::common::dataStructures::Tape &obj);
diff --git a/common/dataStructures/TapeFile.cpp b/common/dataStructures/TapeFile.cpp
index ac4433f0d4..31ea7b56ae 100644
--- a/common/dataStructures/TapeFile.cpp
+++ b/common/dataStructures/TapeFile.cpp
@@ -20,10 +20,14 @@
 #include "common/dataStructures/utils.hpp"
 #include "common/exception/Exception.hpp"
 
+namespace cta {
+namespace common {
+namespace dataStructures {
+
 //------------------------------------------------------------------------------
 // constructor
 //------------------------------------------------------------------------------
-cta::common::dataStructures::TapeFile::TapeFile():
+TapeFile::TapeFile():
   fSeq(0),
   blockId(0),
   compressedSize(0),
@@ -33,7 +37,7 @@ cta::common::dataStructures::TapeFile::TapeFile():
 //------------------------------------------------------------------------------
 // operator==
 //------------------------------------------------------------------------------
-bool cta::common::dataStructures::TapeFile::operator==(const TapeFile &rhs) const {
+bool TapeFile::operator==(const TapeFile &rhs) const {
   return vid==rhs.vid
       && fSeq==rhs.fSeq
       && blockId==rhs.blockId
@@ -45,14 +49,14 @@ bool cta::common::dataStructures::TapeFile::operator==(const TapeFile &rhs) cons
 //------------------------------------------------------------------------------
 // operator!=
 //------------------------------------------------------------------------------
-bool cta::common::dataStructures::TapeFile::operator!=(const TapeFile &rhs) const {
+bool TapeFile::operator!=(const TapeFile &rhs) const {
   return !operator==(rhs);
 }
 
 //------------------------------------------------------------------------------
 // operator<<
 //------------------------------------------------------------------------------
-std::ostream &operator<<(std::ostream &os, const cta::common::dataStructures::TapeFile &obj) {
+std::ostream &operator<<(std::ostream &os, const TapeFile &obj) {
   os << "(vid=" << obj.vid
      << " fSeq=" << obj.fSeq
      << " blockId=" << obj.blockId
@@ -62,3 +66,6 @@ std::ostream &operator<<(std::ostream &os, const cta::common::dataStructures::Ta
   return os;
 }
 
+} // namespace dataStructures
+} // namespace common
+} // namespace cta
diff --git a/common/dataStructures/TapeFile.hpp b/common/dataStructures/TapeFile.hpp
index 03e2952c0a..7135b66747 100644
--- a/common/dataStructures/TapeFile.hpp
+++ b/common/dataStructures/TapeFile.hpp
@@ -70,8 +70,8 @@ struct TapeFile {
 
 }; // struct TapeFile
 
+std::ostream &operator<<(std::ostream &os, const TapeFile &obj);
+
 } // namespace dataStructures
 } // namespace common
 } // namespace cta
-
-std::ostream &operator<<(std::ostream &os, const cta::common::dataStructures::TapeFile &obj);
diff --git a/common/dataStructures/TapeLog.cpp b/common/dataStructures/TapeLog.cpp
index bf9bf1e3fc..2ff760037a 100644
--- a/common/dataStructures/TapeLog.cpp
+++ b/common/dataStructures/TapeLog.cpp
@@ -20,16 +20,20 @@
 #include "common/dataStructures/utils.hpp"
 #include "common/exception/Exception.hpp"
 
+namespace cta {
+namespace common {
+namespace dataStructures {
+
 //------------------------------------------------------------------------------
 // constructor
 //------------------------------------------------------------------------------
-cta::common::dataStructures::TapeLog::TapeLog():
+TapeLog::TapeLog():
   time(0) {}
 
 //------------------------------------------------------------------------------
 // operator==
 //------------------------------------------------------------------------------
-bool cta::common::dataStructures::TapeLog::operator==(const TapeLog &rhs) const {
+bool TapeLog::operator==(const TapeLog &rhs) const {
   return drive==rhs.drive
       && time==rhs.time;
 }
@@ -37,16 +41,19 @@ bool cta::common::dataStructures::TapeLog::operator==(const TapeLog &rhs) const
 //------------------------------------------------------------------------------
 // operator!=
 //------------------------------------------------------------------------------
-bool cta::common::dataStructures::TapeLog::operator!=(const TapeLog &rhs) const {
+bool TapeLog::operator!=(const TapeLog &rhs) const {
   return !operator==(rhs);
 }
 
 //------------------------------------------------------------------------------
 // operator<<
 //------------------------------------------------------------------------------
-std::ostream &operator<<(std::ostream &os, const cta::common::dataStructures::TapeLog &obj) {
+std::ostream &operator<<(std::ostream &os, const TapeLog &obj) {
   os << "(drive=" << obj.drive
      << " time=" << obj.time << ")";
   return os;
 }
 
+} // namespace dataStructures
+} // namespace common
+} // namespace cta
diff --git a/common/dataStructures/TapeLog.hpp b/common/dataStructures/TapeLog.hpp
index 64679a666a..fe37ecd656 100644
--- a/common/dataStructures/TapeLog.hpp
+++ b/common/dataStructures/TapeLog.hpp
@@ -45,8 +45,8 @@ struct TapeLog {
 
 }; // struct TapeLog
 
+std::ostream &operator<<(std::ostream &os, const TapeLog &obj);
+
 } // namespace dataStructures
 } // namespace common
 } // namespace cta
-
-std::ostream &operator<<(std::ostream &os, const cta::common::dataStructures::TapeLog &obj);
diff --git a/common/dataStructures/TapePool.cpp b/common/dataStructures/TapePool.cpp
index cc0ea28470..83b0afbecf 100644
--- a/common/dataStructures/TapePool.cpp
+++ b/common/dataStructures/TapePool.cpp
@@ -20,16 +20,20 @@
 #include "common/dataStructures/utils.hpp"
 #include "common/exception/Exception.hpp"
 
+namespace cta {
+namespace common {
+namespace dataStructures {
+
 //------------------------------------------------------------------------------
 // constructor
 //------------------------------------------------------------------------------
-cta::common::dataStructures::TapePool::TapePool():
+TapePool::TapePool():
   nbPartialTapes(0) {}
 
 //------------------------------------------------------------------------------
 // operator==
 //------------------------------------------------------------------------------
-bool cta::common::dataStructures::TapePool::operator==(const TapePool &rhs) const {
+bool TapePool::operator==(const TapePool &rhs) const {
   return name==rhs.name
       && nbPartialTapes==rhs.nbPartialTapes
       && encryption==rhs.encryption
@@ -41,14 +45,14 @@ bool cta::common::dataStructures::TapePool::operator==(const TapePool &rhs) cons
 //------------------------------------------------------------------------------
 // operator!=
 //------------------------------------------------------------------------------
-bool cta::common::dataStructures::TapePool::operator!=(const TapePool &rhs) const {
+bool TapePool::operator!=(const TapePool &rhs) const {
   return !operator==(rhs);
 }
 
 //------------------------------------------------------------------------------
 // operator<<
 //------------------------------------------------------------------------------
-std::ostream &operator<<(std::ostream &os, const cta::common::dataStructures::TapePool &obj) {
+std::ostream &operator<<(std::ostream &os, const TapePool &obj) {
   os << "(name=" << obj.name
      << " nbPartialTapes=" << obj.nbPartialTapes
      << " encryption=" << obj.encryption
@@ -58,3 +62,6 @@ std::ostream &operator<<(std::ostream &os, const cta::common::dataStructures::Ta
   return os;
 }
 
+} // namespace dataStructures
+} // namespace common
+} // namespace cta
diff --git a/common/dataStructures/TapePool.hpp b/common/dataStructures/TapePool.hpp
index 253d6ca35c..f7f05be909 100644
--- a/common/dataStructures/TapePool.hpp
+++ b/common/dataStructures/TapePool.hpp
@@ -44,14 +44,14 @@ struct TapePool {
   std::string name;
   uint64_t nbPartialTapes;
   bool encryption;
-  cta::common::dataStructures::EntryLog creationLog;
-  cta::common::dataStructures::EntryLog lastModificationLog;
+  EntryLog creationLog;
+  EntryLog lastModificationLog;
   std::string comment;
 
 }; // struct TapePool
 
+std::ostream &operator<<(std::ostream &os, const TapePool &obj);
+
 } // namespace dataStructures
 } // namespace common
 } // namespace cta
-
-std::ostream &operator<<(std::ostream &os, const cta::common::dataStructures::TapePool &obj);
diff --git a/common/dataStructures/UpdateFileInfoRequest.cpp b/common/dataStructures/UpdateFileInfoRequest.cpp
index 73ca4fd5ae..2709cd0b3b 100644
--- a/common/dataStructures/UpdateFileInfoRequest.cpp
+++ b/common/dataStructures/UpdateFileInfoRequest.cpp
@@ -20,16 +20,20 @@
 #include "common/dataStructures/utils.hpp"
 #include "common/exception/Exception.hpp"
 
+namespace cta {
+namespace common {
+namespace dataStructures {
+
 //------------------------------------------------------------------------------
 // constructor
 //------------------------------------------------------------------------------
-cta::common::dataStructures::UpdateFileInfoRequest::UpdateFileInfoRequest():
+UpdateFileInfoRequest::UpdateFileInfoRequest():
   archiveFileID(0) {}
 
 //------------------------------------------------------------------------------
 // operator==
 //------------------------------------------------------------------------------
-bool cta::common::dataStructures::UpdateFileInfoRequest::operator==(const UpdateFileInfoRequest &rhs) const {
+bool UpdateFileInfoRequest::operator==(const UpdateFileInfoRequest &rhs) const {
   return archiveFileID==rhs.archiveFileID
       && drData==rhs.drData;
 }
@@ -37,16 +41,19 @@ bool cta::common::dataStructures::UpdateFileInfoRequest::operator==(const Update
 //------------------------------------------------------------------------------
 // operator!=
 //------------------------------------------------------------------------------
-bool cta::common::dataStructures::UpdateFileInfoRequest::operator!=(const UpdateFileInfoRequest &rhs) const {
+bool UpdateFileInfoRequest::operator!=(const UpdateFileInfoRequest &rhs) const {
   return !operator==(rhs);
 }
 
 //------------------------------------------------------------------------------
 // operator<<
 //------------------------------------------------------------------------------
-std::ostream &operator<<(std::ostream &os, const cta::common::dataStructures::UpdateFileInfoRequest &obj) {
+std::ostream &operator<<(std::ostream &os, const UpdateFileInfoRequest &obj) {
   os << "(archiveFileID=" << obj.archiveFileID
      << " drData=" << obj.drData << ")";
   return os;
 }
 
+} // namespace dataStructures
+} // namespace common
+} // namespace cta
diff --git a/common/dataStructures/UpdateFileInfoRequest.hpp b/common/dataStructures/UpdateFileInfoRequest.hpp
index 343a6e1c86..f5a86f0935 100644
--- a/common/dataStructures/UpdateFileInfoRequest.hpp
+++ b/common/dataStructures/UpdateFileInfoRequest.hpp
@@ -42,12 +42,12 @@ struct UpdateFileInfoRequest {
   bool operator!=(const UpdateFileInfoRequest &rhs) const;
 
   uint64_t archiveFileID;
-  cta::common::dataStructures::DRData drData;
+  DRData drData;
 
 }; // struct UpdateFileInfoRequest
 
+std::ostream &operator<<(std::ostream &os, const UpdateFileInfoRequest &obj);
+
 } // namespace dataStructures
 } // namespace common
 } // namespace cta
-
-std::ostream &operator<<(std::ostream &os, const cta::common::dataStructures::UpdateFileInfoRequest &obj);
diff --git a/common/dataStructures/UpdateFileStorageClassRequest.cpp b/common/dataStructures/UpdateFileStorageClassRequest.cpp
index 278ec81de8..a2c99f9b7b 100644
--- a/common/dataStructures/UpdateFileStorageClassRequest.cpp
+++ b/common/dataStructures/UpdateFileStorageClassRequest.cpp
@@ -20,16 +20,20 @@
 #include "common/dataStructures/utils.hpp"
 #include "common/exception/Exception.hpp"
 
+namespace cta {
+namespace common {
+namespace dataStructures {
+
 //------------------------------------------------------------------------------
 // constructor
 //------------------------------------------------------------------------------
-cta::common::dataStructures::UpdateFileStorageClassRequest::UpdateFileStorageClassRequest():
+UpdateFileStorageClassRequest::UpdateFileStorageClassRequest():
   archiveFileID(0) {}
 
 //------------------------------------------------------------------------------
 // operator==
 //------------------------------------------------------------------------------
-bool cta::common::dataStructures::UpdateFileStorageClassRequest::operator==(const UpdateFileStorageClassRequest &rhs) const {
+bool UpdateFileStorageClassRequest::operator==(const UpdateFileStorageClassRequest &rhs) const {
   return requester==rhs.requester
       && archiveFileID==rhs.archiveFileID
       && storageClass==rhs.storageClass
@@ -39,14 +43,14 @@ bool cta::common::dataStructures::UpdateFileStorageClassRequest::operator==(cons
 //------------------------------------------------------------------------------
 // operator!=
 //------------------------------------------------------------------------------
-bool cta::common::dataStructures::UpdateFileStorageClassRequest::operator!=(const UpdateFileStorageClassRequest &rhs) const {
+bool UpdateFileStorageClassRequest::operator!=(const UpdateFileStorageClassRequest &rhs) const {
   return !operator==(rhs);
 }
 
 //------------------------------------------------------------------------------
 // operator<<
 //------------------------------------------------------------------------------
-std::ostream &operator<<(std::ostream &os, const cta::common::dataStructures::UpdateFileStorageClassRequest &obj) {
+std::ostream &operator<<(std::ostream &os, const UpdateFileStorageClassRequest &obj) {
   os << "(requester=" << obj.requester
      << " archiveFileID=" << obj.archiveFileID
      << " storageClass=" << obj.storageClass
@@ -54,3 +58,6 @@ std::ostream &operator<<(std::ostream &os, const cta::common::dataStructures::Up
   return os;
 }
 
+} // namespace dataStructures
+} // namespace common
+} // namespace cta
diff --git a/common/dataStructures/UpdateFileStorageClassRequest.hpp b/common/dataStructures/UpdateFileStorageClassRequest.hpp
index 8c312c0f01..e120ff2783 100644
--- a/common/dataStructures/UpdateFileStorageClassRequest.hpp
+++ b/common/dataStructures/UpdateFileStorageClassRequest.hpp
@@ -42,15 +42,15 @@ struct UpdateFileStorageClassRequest {
 
   bool operator!=(const UpdateFileStorageClassRequest &rhs) const;
 
-  cta::common::dataStructures::UserIdentity requester;
+  UserIdentity requester;
   uint64_t archiveFileID;
   std::string storageClass;
-  cta::common::dataStructures::DRData drData;
+  DRData drData;
 
 }; // struct UpdateFileStorageClassRequest
 
+std::ostream &operator<<(std::ostream &os, const UpdateFileStorageClassRequest &obj);
+
 } // namespace dataStructures
 } // namespace common
 } // namespace cta
-
-std::ostream &operator<<(std::ostream &os, const cta::common::dataStructures::UpdateFileStorageClassRequest &obj);
diff --git a/common/dataStructures/UserIdentity.cpp b/common/dataStructures/UserIdentity.cpp
index bafdfd0296..e7838d1a69 100644
--- a/common/dataStructures/UserIdentity.cpp
+++ b/common/dataStructures/UserIdentity.cpp
@@ -33,7 +33,8 @@ UserIdentity::UserIdentity() {}
 // operator==
 //------------------------------------------------------------------------------
 bool UserIdentity::operator==(const UserIdentity &rhs) const {
-  return name==rhs.name && group==rhs.group;
+  return name==rhs.name
+      && group==rhs.group;
 }
 
 //------------------------------------------------------------------------------
@@ -48,11 +49,10 @@ bool UserIdentity::operator!=(const UserIdentity &rhs) const {
 //------------------------------------------------------------------------------
 std::ostream &operator<<(std::ostream &os, const UserIdentity &obj) {
   os << "(name=" << obj.name
-  << " group=" << obj.group << ")";
+     << " group=" << obj.group << ")";
   return os;
 }
 
 } // namespace dataStructures
 } // namespace common
 } // namespace cta
-
diff --git a/common/dataStructures/UserIdentity.hpp b/common/dataStructures/UserIdentity.hpp
index 12e831a47f..2daa73a525 100644
--- a/common/dataStructures/UserIdentity.hpp
+++ b/common/dataStructures/UserIdentity.hpp
@@ -18,7 +18,9 @@
 
 #pragma once
 
-#include <ostream>
+#include <list>
+#include <map>
+#include <stdint.h>
 #include <string>
 
 
@@ -42,7 +44,7 @@ struct UserIdentity {
 
 }; // struct UserIdentity
 
-std::ostream &operator<<(std::ostream &os, const cta::common::dataStructures::UserIdentity &obj);
+std::ostream &operator<<(std::ostream &os, const UserIdentity &obj);
 
 } // namespace dataStructures
 } // namespace common
diff --git a/common/dataStructures/VerifyInfo.cpp b/common/dataStructures/VerifyInfo.cpp
index d5c76a52c5..1811ea42b7 100644
--- a/common/dataStructures/VerifyInfo.cpp
+++ b/common/dataStructures/VerifyInfo.cpp
@@ -20,10 +20,14 @@
 #include "common/dataStructures/utils.hpp"
 #include "common/exception/Exception.hpp"
 
+namespace cta {
+namespace common {
+namespace dataStructures {
+
 //------------------------------------------------------------------------------
 // constructor
 //------------------------------------------------------------------------------
-cta::common::dataStructures::VerifyInfo::VerifyInfo():
+VerifyInfo::VerifyInfo():
   totalFiles(0),
   totalSize(0),
   filesToVerify(0),
@@ -33,7 +37,7 @@ cta::common::dataStructures::VerifyInfo::VerifyInfo():
 //------------------------------------------------------------------------------
 // operator==
 //------------------------------------------------------------------------------
-bool cta::common::dataStructures::VerifyInfo::operator==(const VerifyInfo &rhs) const {
+bool VerifyInfo::operator==(const VerifyInfo &rhs) const {
   return vid==rhs.vid
       && tag==rhs.tag
       && totalFiles==rhs.totalFiles
@@ -49,14 +53,14 @@ bool cta::common::dataStructures::VerifyInfo::operator==(const VerifyInfo &rhs)
 //------------------------------------------------------------------------------
 // operator!=
 //------------------------------------------------------------------------------
-bool cta::common::dataStructures::VerifyInfo::operator!=(const VerifyInfo &rhs) const {
+bool VerifyInfo::operator!=(const VerifyInfo &rhs) const {
   return !operator==(rhs);
 }
 
 //------------------------------------------------------------------------------
 // operator<<
 //------------------------------------------------------------------------------
-std::ostream &operator<<(std::ostream &os, const cta::common::dataStructures::VerifyInfo &obj) {
+std::ostream &operator<<(std::ostream &os, const VerifyInfo &obj) {
   os << "(vid=" << obj.vid
      << " tag=" << obj.tag
      << " totalFiles=" << obj.totalFiles
@@ -70,3 +74,6 @@ std::ostream &operator<<(std::ostream &os, const cta::common::dataStructures::Ve
   return os;
 }
 
+} // namespace dataStructures
+} // namespace common
+} // namespace cta
diff --git a/common/dataStructures/VerifyInfo.hpp b/common/dataStructures/VerifyInfo.hpp
index 005f049090..57ec4e8d02 100644
--- a/common/dataStructures/VerifyInfo.hpp
+++ b/common/dataStructures/VerifyInfo.hpp
@@ -48,13 +48,13 @@ struct VerifyInfo {
   uint64_t filesFailed;
   uint64_t filesVerified;
   std::string verifyStatus;
-  cta::common::dataStructures::EntryLog creationLog;
+  EntryLog creationLog;
   std::map<uint64_t,std::string> errors;
 
 }; // struct VerifyInfo
 
+std::ostream &operator<<(std::ostream &os, const VerifyInfo &obj);
+
 } // namespace dataStructures
 } // namespace common
 } // namespace cta
-
-std::ostream &operator<<(std::ostream &os, const cta::common::dataStructures::VerifyInfo &obj);
diff --git a/common/dataStructures/WriteTestResult.cpp b/common/dataStructures/WriteTestResult.cpp
index c585fda634..779ef3faf3 100644
--- a/common/dataStructures/WriteTestResult.cpp
+++ b/common/dataStructures/WriteTestResult.cpp
@@ -20,10 +20,14 @@
 #include "common/dataStructures/utils.hpp"
 #include "common/exception/Exception.hpp"
 
+namespace cta {
+namespace common {
+namespace dataStructures {
+
 //------------------------------------------------------------------------------
 // constructor
 //------------------------------------------------------------------------------
-cta::common::dataStructures::WriteTestResult::WriteTestResult():
+WriteTestResult::WriteTestResult():
   noOfFilesWritten(0),
   totalBytesWritten(0),
   totalFilesWritten(0),
@@ -32,7 +36,7 @@ cta::common::dataStructures::WriteTestResult::WriteTestResult():
 //------------------------------------------------------------------------------
 // operator==
 //------------------------------------------------------------------------------
-bool cta::common::dataStructures::WriteTestResult::operator==(const WriteTestResult &rhs) const {
+bool WriteTestResult::operator==(const WriteTestResult &rhs) const {
   return driveName==rhs.driveName
       && vid==rhs.vid
       && noOfFilesWritten==rhs.noOfFilesWritten
@@ -46,14 +50,14 @@ bool cta::common::dataStructures::WriteTestResult::operator==(const WriteTestRes
 //------------------------------------------------------------------------------
 // operator!=
 //------------------------------------------------------------------------------
-bool cta::common::dataStructures::WriteTestResult::operator!=(const WriteTestResult &rhs) const {
+bool WriteTestResult::operator!=(const WriteTestResult &rhs) const {
   return !operator==(rhs);
 }
 
 //------------------------------------------------------------------------------
 // operator<<
 //------------------------------------------------------------------------------
-std::ostream &operator<<(std::ostream &os, const cta::common::dataStructures::WriteTestResult &obj) {
+std::ostream &operator<<(std::ostream &os, const WriteTestResult &obj) {
   os << "(driveName=" << obj.driveName
      << " vid=" << obj.vid
      << " noOfFilesWritten=" << obj.noOfFilesWritten
@@ -65,3 +69,6 @@ std::ostream &operator<<(std::ostream &os, const cta::common::dataStructures::Wr
   return os;
 }
 
+} // namespace dataStructures
+} // namespace common
+} // namespace cta
diff --git a/common/dataStructures/WriteTestResult.hpp b/common/dataStructures/WriteTestResult.hpp
index 79ce03213c..7bb0398907 100644
--- a/common/dataStructures/WriteTestResult.hpp
+++ b/common/dataStructures/WriteTestResult.hpp
@@ -50,8 +50,8 @@ struct WriteTestResult {
 
 }; // struct WriteTestResult
 
+std::ostream &operator<<(std::ostream &os, const WriteTestResult &obj);
+
 } // namespace dataStructures
 } // namespace common
 } // namespace cta
-
-std::ostream &operator<<(std::ostream &os, const cta::common::dataStructures::WriteTestResult &obj);
diff --git a/common/dataStructures/utils.cpp b/common/dataStructures/utils.cpp
index 13e2474551..181052e751 100644
--- a/common/dataStructures/utils.cpp
+++ b/common/dataStructures/utils.cpp
@@ -18,7 +18,11 @@
 
 #include "common/dataStructures/utils.hpp"
 
-std::ostream &operator<<(std::ostream &os, const std::map<uint64_t,cta::common::dataStructures::TapeFile> &map) {
+namespace cta {
+namespace common {
+namespace dataStructures {
+
+std::ostream &operator<<(std::ostream &os, const std::map<uint64_t,TapeFile> &map) {
   os << "(";
   for(auto it = map.begin(); it != map.end(); it++) {
     os << " key=" << it->first << " value=" << it->second << " ";
@@ -50,11 +54,15 @@ std::ostream &operator<<(std::ostream &os, const std::map<uint64_t,std::pair<std
   return os;
 }
 
-std::ostream &operator<<(std::ostream &os, const std::map<std::string,std::pair<uint64_t,cta::common::dataStructures::TapeFile>> &map) {
+std::ostream &operator<<(std::ostream &os, const std::map<std::string,std::pair<uint64_t,TapeFile>> &map) {
   os << "(";
   for(auto it = map.begin(); it != map.end(); it++) {
     os << " key=" << it->first << " value.first=" << it->second.first << "  value.second=" << it->second.second;
   }
   os << ")";
   return os;
-}
\ No newline at end of file
+}
+
+} // namespace dataStructures
+} // namespace common
+} // namespace cta
\ No newline at end of file
diff --git a/common/dataStructures/utils.hpp b/common/dataStructures/utils.hpp
index b1a5f37f64..b7fb7ea76e 100644
--- a/common/dataStructures/utils.hpp
+++ b/common/dataStructures/utils.hpp
@@ -23,9 +23,17 @@
 #include <iostream>
 #include <map>
 
-std::ostream &operator<<(std::ostream &os, const std::map<uint64_t,cta::common::dataStructures::TapeFile> &map);
+namespace cta {
+namespace common {
+namespace dataStructures {
+  
+std::ostream &operator<<(std::ostream &os, const std::map<uint64_t,TapeFile> &map);
 std::ostream &operator<<(std::ostream &os, const std::map<uint64_t,std::string> &map);
 std::ostream &operator<<(std::ostream &os, const std::pair<std::string,std::string> &pair);
 std::ostream &operator<<(std::ostream &os, const std::map<uint64_t,std::pair<std::string,std::string>> &map);
-std::ostream &operator<<(std::ostream &os, const std::map<std::string,std::pair<uint64_t,cta::common::dataStructures::TapeFile>> &map);
-std::ostream &operator<<(std::ostream &os, const std::map<uint64_t,std::pair<std::string,std::string>> &map);
\ No newline at end of file
+std::ostream &operator<<(std::ostream &os, const std::map<std::string,std::pair<uint64_t,TapeFile>> &map);
+std::ostream &operator<<(std::ostream &os, const std::map<uint64_t,std::pair<std::string,std::string>> &map);
+
+} // namespace dataStructures
+} // namespace common
+} // namespace cta
\ No newline at end of file
-- 
GitLab