use new managemnet model - add ugly set support; apply it for cxx header

src/doim/base.hpp

@@ -35,7 +35,7 @@ class Base : public enable_make_shared<T>
 
     bool isUnique()
     {
-        std::shared_ptr<T> key(std::shared_ptr<T>(), static_cast<T*>(this));
+        shared_ptr<T> key(shared_ptr<T>(), static_cast<T*>(this));
         return gManagerObjectMixin->isUnique(key);
     }
 

src/doim/cxx/cxx_header.cpp

@@ -15,4 +15,20 @@ CxxHeader::CxxHeader(const EType type,
     ASSERT(gManager->isUnique(file));
     ASSERT(gManager->isUnique(cxxIncludeDirectories));
 }
+
+std::ostream& operator<<(std::ostream& out, const CxxHeader& header)
+{
+    out << "header { type: ";
+    switch (header.type())
+    {
+        case CxxHeader::EType::kUser:
+            out << "user";
+            break;
+        case CxxHeader::EType::kSystem:
+            out << "system";
+            break;
+    }
+    out << ", file: " << header.file()->path() << "}" << std::endl;
+    return out;
+}
 }

src/doim/cxx/cxx_header.h

@@ -6,6 +6,7 @@
 #include "doim/base.hpp"
 #include "doim/cxx/cxx_include_directory.h"
 #include "doim/fs/fs_file.h"
+#include "doim/set.hpp"
 #include <memory>
 #include <tuple>
 #include <unordered>
@@ -14,7 +15,8 @@ namespace doim
 {
 class CxxHeader;
 typedef shared_ptr<CxxHeader> CxxHeaderSPtr;
-typedef unordered_set<CxxHeaderSPtr> CxxHeaderSet;
+
+typedef NewObjectSet<CxxHeader> CxxHeaderSet;
 typedef shared_ptr<CxxHeaderSet> CxxHeaderSetSPtr;
 
 struct CxxHeaderEnums
@@ -52,4 +54,6 @@ class CxxHeader : public CxxHeaderEnums,
         return std::get<2>(mArgs);
     }
 };
+
+std::ostream& operator<<(std::ostream& out, const CxxHeader& header);
 }

src/doim/cxx/cxx_include_directory.cpp

@@ -17,7 +17,7 @@ CxxIncludeDirectory::CxxIncludeDirectory(const EType type,
 {
     ASSERT(directory != nullptr);
     ASSERT(gManager->isUnique(directory));
-    ASSERT(gManager->isUnique(headerFiles));
+    ASSERT(headerFiles->isUnique());
 }
 
 void CxxIncludeDirectory::finally()

src/doim/cxx/cxx_include_directory.h

@@ -6,6 +6,7 @@
 #include "doim/base.hpp"
 #include "doim/fs/fs_directory.h"
 #include "doim/fs/fs_file.h"
+#include "doim/set.hpp"
 #include <memory>
 #include <tuple>
 #include <type_traits>
@@ -16,7 +17,7 @@ namespace doim
 class CxxHeader;
 
 typedef shared_ptr<CxxHeader> CxxHeaderSPtr;
-typedef unordered_set<CxxHeaderSPtr> CxxHeaderSet;
+typedef NewObjectSet<CxxHeader> CxxHeaderSet;
 typedef shared_ptr<CxxHeaderSet> CxxHeaderSetSPtr;
 
 class CxxIncludeDirectory;

src/doim/doim.dbs

@@ -26,6 +26,7 @@ cxx_library doim
         doim/manager_object_mixin.hpp
         doim/manager_object_set_mixin.hpp
         doim/manager.h
+        doim/set.hpp
     ;
 
     cxx_library:

src/doim/manager.cpp

@@ -172,20 +172,4 @@ std::ostream& operator<<(std::ostream& out, const CxxIncludeDirectorySet& direct
     return out;
 }
 
-std::ostream& operator<<(std::ostream& out, const CxxHeader& header)
-{
-    out << "header { type: ";
-    switch (header.type())
-    {
-        case CxxHeader::EType::kUser:
-            out << "user";
-            break;
-        case CxxHeader::EType::kSystem:
-            out << "system";
-            break;
-    }
-    out << ", file: " << header.file()->path() << "}" << std::endl;
-    return out;
-}
-
 } // namespace doim

src/doim/manager.h

@@ -3,7 +3,6 @@
 
 #pragma once
 
-#include "doim/cxx/cxx_header.h"
 #include "doim/cxx/cxx_include_directory.h"
 #include "doim/cxx/cxx_object_file.h"
 #include "doim/cxx/cxx_program.h"
@@ -29,8 +28,7 @@ typedef shared_ptr<Manager> ManagerSPtr;
 
 extern ManagerSPtr gManager;
 
-class Manager : public ManagerObjectSetMixin<CxxHeader>,
-                public ManagerObjectSetMixin<CxxIncludeDirectory>,
+class Manager : public ManagerObjectSetMixin<CxxIncludeDirectory>,
                 public ManagerObjectSetMixin<CxxObjectFile>,
                 public ManagerObjectSetMixin<CxxStaticLibrary>,
                 public ManagerObjectMixin<CxxProgram>,
@@ -107,12 +105,6 @@ class Manager : public ManagerObjectSetMixin<CxxHeader>,
     using ManagerObjectSetMixin<CxxIncludeDirectory>::unique;
     using ManagerObjectSetMixin<CxxIncludeDirectory>::isUnique;
 
-    using ManagerObjectMixin<CxxHeader>::unique;
-    using ManagerObjectMixin<CxxHeader>::isUnique;
-
-    using ManagerObjectSetMixin<CxxHeader>::unique;
-    using ManagerObjectSetMixin<CxxHeader>::isUnique;
-
     using ManagerObjectMixin<CxxObjectFile>::unique;
     using ManagerObjectMixin<CxxObjectFile>::isUnique;
 

src/doim/set.hpp

@@ -0,0 +1,156 @@
+//  Copyright © 2016 George Georgiev. All rights reserved.
+//
+
+#pragma once
+
+#include "doim/manager_object_mixin.hpp"
+#include "err/err_assert.h"
+#include <boost/functional/hash/hash.hpp>
+#include <algorithm>
+#include <initializer_list>
+#include <iosfwd>
+#include <memory>
+#include <string_view>
+#include <typeindex>
+#include <unordered>
+#include <unordered_map>
+#include <utility>
+#include <vector>
+#include <stddef.h>
+
+namespace doim
+{
+template <typename T, typename S>
+class SetManagerObjectMixin
+{
+public:
+    typedef T MixinObject;
+    typedef shared_ptr<MixinObject> MixinObjectSPtr;
+
+    typedef S MixinObjectSet;
+    typedef shared_ptr<MixinObjectSet> MixinObjectSetSPtr;
+
+    struct Hasher
+    {
+        std::size_t operator()(const MixinObjectSetSPtr& objects) const
+        {
+            std::vector<MixinObjectSPtr> vector;
+            vector.reserve(objects->size());
+            vector.insert(vector.begin(), objects->begin(), objects->end());
+            std::sort(vector.begin(), vector.end());
+
+            std::hash<MixinObjectSPtr> hash;
+
+            std::size_t seed = 0;
+            for (const auto& object : vector)
+            {
+                ASSERT(object != nullptr);
+                boost::hash_combine(seed, hash(object));
+            }
+
+            return seed;
+        }
+
+        bool operator()(const MixinObjectSetSPtr& objects1,
+                        const MixinObjectSetSPtr& objects2) const
+        {
+            return *objects1 == *objects2;
+        }
+    };
+
+    MixinObjectSetSPtr unique(const MixinObjectSetSPtr& objects)
+    {
+        if (objects == nullptr)
+            return objects;
+
+        for (const auto& object : *objects)
+            ASSERT(object->isUnique());
+
+        boost::unique_lock<boost::shared_mutex> lock(mMixinObjectSetsMutex);
+        return *mMixinObjectSets.insert(objects).first;
+    }
+
+    bool isUnique(const MixinObjectSetSPtr& object) const
+    {
+        return object == find(object);
+    }
+
+    MixinObjectSetSPtr find(const MixinObjectSetSPtr& object) const
+    {
+        if (object == nullptr)
+            return object;
+
+        boost::shared_lock<boost::shared_mutex> lock(mMixinObjectSetsMutex);
+        const auto& it = mMixinObjectSets.find(object);
+        if (it == mMixinObjectSets.end())
+            return nullptr;
+        return *it;
+    }
+
+protected:
+    mutable boost::shared_mutex mMixinObjectSetsMutex;
+    unordered_set<MixinObjectSetSPtr, Hasher, Hasher> mMixinObjectSets;
+};
+
+template <typename T>
+class NewObjectSet : public enable_make_shared<NewObjectSet<T>>,
+                     public std::unordered_set<shared_ptr<T>>
+{
+public:
+    static shared_ptr<NewObjectSet<T>> unique(const shared_ptr<NewObjectSet<T>>& set)
+    {
+        return gManagerObjectSetMixin->unique(set);
+    }
+
+    static shared_ptr<NewObjectSet<T>> unique(
+        const std::initializer_list<shared_ptr<T>>& list)
+    {
+        return gManagerObjectSetMixin->unique(
+            enable_make_shared<NewObjectSet<T>>::make(list));
+    }
+
+    using std::unordered_set<shared_ptr<T>>::unordered_set;
+
+    bool isUnique()
+    {
+        shared_ptr<NewObjectSet<T>> key(shared_ptr<NewObjectSet<T>>(), this);
+        return gManagerObjectSetMixin->isUnique(key);
+    }
+
+    struct Hasher
+    {
+        std::size_t operator()(const shared_ptr<NewObjectSet<T>>& objects) const
+        {
+            std::vector<shared_ptr<T>> vector;
+            vector.reserve(objects->size());
+            vector.insert(vector.begin(), objects->begin(), objects->end());
+            std::sort(vector.begin(), vector.end());
+
+            std::hash<shared_ptr<T>> hash;
+
+            std::size_t seed = 0;
+            for (const auto& object : vector)
+            {
+                ASSERT(object != nullptr);
+                boost::hash_combine(seed, hash(object));
+            }
+
+            return seed;
+        }
+
+        bool operator()(const shared_ptr<NewObjectSet<T>>& objects1,
+                        const shared_ptr<NewObjectSet<T>>& objects2) const
+        {
+            return *objects1 == *objects2;
+        }
+    };
+
+protected:
+    static shared_ptr<SetManagerObjectMixin<T, NewObjectSet<T>>> gManagerObjectSetMixin;
+};
+
+template <typename T>
+shared_ptr<SetManagerObjectMixin<T, NewObjectSet<T>>> NewObjectSet<
+    T>::gManagerObjectSetMixin =
+    std::make_shared<SetManagerObjectMixin<T, NewObjectSet<T>>>();
+}

src/dom/cxx/cxx_library.cpp

@@ -186,11 +186,11 @@ doim::CxxHeaderSetSPtr CxxLibrary::publicCxxHeaders(
         const auto& directories = sublibraryCxxIncludeDirectories(root);
         for (const auto& header : *mCxxPublicHeaders)
         {
-            auto cxxHeader = doim::unique<doim::CxxHeader>(type, header, directories);
+            auto cxxHeader = doim::CxxHeader::unique(type, header, directories);
             headers->insert(cxxHeader);
         }
     }
-    return doim::gManager->unique(headers);
+    return doim::CxxHeaderSet::unique(headers);
 }
 
 doim::CxxHeaderSetSPtr CxxLibrary::indirectCxxHeaders(
@@ -207,7 +207,7 @@ doim::CxxHeaderSetSPtr CxxLibrary::indirectCxxHeaders(
         const auto& libHeaders = cxxLibrary->recursiveCxxHeaders(root);
         headers->insert(libHeaders->begin(), libHeaders->end());
     }
-    return doim::gManager->unique(headers);
+    return doim::CxxHeaderSet::unique(headers);
 }
 
 doim::CxxHeaderSetSPtr CxxLibrary::recursiveCxxHeaders(
@@ -228,7 +228,7 @@ doim::CxxHeaderSetSPtr CxxLibrary::recursiveCxxHeaders(
         const auto& libHeaders = cxxLibrary->recursiveCxxHeaders(root);
         headers->insert(libHeaders->begin(), libHeaders->end());
     }
-    return doim::gManager->unique(headers);
+    return doim::CxxHeaderSet::unique(headers);
 }
 
 void CxxLibrary::resetRecursiveCxxIncludeDirectoriesMemoization()

src/dom/cxx/cxx_private_headers_mixin.hpp

@@ -4,6 +4,7 @@
 #pragma once
 
 #include "doim/cxx/cxx_file.h"
+#include "doim/cxx/cxx_header.h"
 #include "doim/cxx/cxx_object_file.h"
 #include "doim/fs/fs_file.h"
 #include "doim/manager.h"
@@ -63,11 +64,12 @@ class CxxPrivateHeadersMixin
                 static_cast<const Subject*>(this)->indirectCxxIncludeDirectories(root);
             for (const auto& header : *mCxxPrivateHeaders)
             {
-                const auto& cxxHeader = doim::CxxHeader::make(type, header, directories);
-                headers->insert(doim::gManager->unique(cxxHeader));
+                const auto& cxxHeader =
+                    doim::CxxHeader::unique(type, header, directories);
+                headers->insert(cxxHeader);
             }
         }
-        return doim::gManager->unique(headers);
+        return doim::CxxHeaderSet::unique(headers);
     }
 
 private:

src/dom/cxx/cxx_program.cpp

@@ -104,6 +104,6 @@ doim::CxxHeaderSetSPtr CxxProgram::cxxHeaders(const doim::FsDirectorySPtr& root)
         const auto& libHeaders = cxxLibrary->recursiveCxxHeaders(root);
         headers->insert(libHeaders->begin(), libHeaders->end());
     }
-    return doim::gManager->unique(headers);
+    return doim::CxxHeaderSet::unique(headers);
 }
 }

src/system/stl.dbs

@@ -18,6 +18,7 @@ cxx_library stl
         ifstream
         iosfwd
         iostream
+        initializer_list
         iterator
         limits
         map

src/task/cxx/cxx_header_crc_task.cpp

@@ -20,7 +20,7 @@ CxxHeaderCrcTask::CxxHeaderCrcTask(
     const doim::CxxIncludeDirectorySPtr& currentIncludeDirectory)
     : Base(cxxHeader, currentIncludeDirectory)
 {
-    ASSERT(doim::gManager->isUnique(cxxHeader));
+    ASSERT(cxxHeader->isUnique());
     ASSERT(doim::gManager->isUnique(currentIncludeDirectory));
 }