refactor cxx headers; add some tests

src/doim/cxx/cxx_include_directory.cpp

@@ -21,9 +21,7 @@ ECode CxxIncludeDirectory::findHeader(
     CxxHeaderInfo result;
 
     if (currentIncludeDirectory != nullptr)
-    {
         result = {currentIncludeDirectory->findHeader(header), currentIncludeDirectory};
-    }
 
     for (const auto& directory : *includeDirectories)
     {

src/dom/cxx/cxx_files_mixin.hpp

@@ -39,10 +39,14 @@ class CxxFilesMixin
         doim::CxxFileSet cxxFiles;
 
         const auto& directories =
-            static_cast<const Subject*>(this)->recursiveCxxIncludeDirectories(root);
+            static_cast<const Subject*>(this)->visibleCxxIncludeDirectories(root);
 
         for (const auto& directory : *directories)
-            DLOG("include directory: {0}", directory->directory()->path(root));
+        {
+            DLOG("include directory: {}", directory->directory()->path(root));
+            for (const auto& header : *directory->headerFiles())
+                DLOG("    header: {}", header->file()->path(root));
+        }
 
         for (const auto& fsFile : mCxxFilesList)
         {

src/dom/cxx/cxx_headers_mixin.hpp

@@ -76,7 +76,7 @@ class CxxHeadersMixin
 
         auto type = static_cast<const Subject*>(this)->cxxHeaderType();
         const auto& directories =
-            static_cast<const Subject*>(this)->indirectCxxIncludeDirectories(root);
+            static_cast<const Subject*>(this)->recursivePublicCxxIncludeDirectories(root);
         for (const auto& header : *files)
         {
             const auto& cxxHeader = doim::CxxHeader::unique(

src/dom/cxx/cxx_library.cpp

@@ -35,7 +35,7 @@ doim::AttributeValueSPtr CxxLibrary::gPrivate =
 
 CxxLibrary::CxxLibrary()
     : mType(EType::kUser)
-    , mRecursiveCxxIncludeDirectoriesMemoization(
+    , mIndirectPublicCxxIncludeDirectoriesMemoization(
           std::make_shared<RecursiveCxxIncludeDirectoriesMemoization>())
 {
     resetRecursiveCxxIncludeDirectoriesMemoization();
@@ -127,21 +127,30 @@ doim::CxxIncludeDirectorySPtr CxxLibrary::cxxPublicIncludeDirectory(
                                              publicCxxHeaders(root));
 }
 
-doim::CxxIncludeDirectorySetSPtr CxxLibrary::sublibraryCxxIncludeDirectories(
+doim::CxxIncludeDirectorySetSPtr CxxLibrary::indirectPublicCxxIncludeDirectories(
     const doim::FsDirectorySPtr& root) const
 {
-    auto directories = doim::CxxIncludeDirectorySet::make();
+    auto fn = [this](doim::FsDirectorySPtr root,
+                     std::vector<dp::Handle::ControllerSPtr>& dependencies) {
 
-    for (const auto& cxxLibrary : mCxxLibraries)
-    {
-        const auto& libDirectories = cxxLibrary->recursiveCxxIncludeDirectories(root);
-        directories->insert(libDirectories->begin(), libDirectories->end());
-    }
+        auto directories = doim::CxxIncludeDirectorySet::make();
 
-    return doim::CxxIncludeDirectorySet::unique(directories);
+        for (const auto& cxxLibrary : mCxxLibraries)
+        {
+            const auto& libDirectories =
+                cxxLibrary->recursivePublicCxxIncludeDirectories(root);
+            directories->insert(libDirectories->begin(), libDirectories->end());
+        }
+
+        return doim::CxxIncludeDirectorySet::unique(directories);
+    };
+
+    return mIndirectPublicCxxIncludeDirectoriesMemoization->get(mMemoizationHandle,
+                                                                root,
+                                                                fn);
 }
 
-doim::CxxIncludeDirectorySetSPtr CxxLibrary::indirectCxxIncludeDirectories(
+doim::CxxIncludeDirectorySetSPtr CxxLibrary::recursivePublicCxxIncludeDirectories(
     const doim::FsDirectorySPtr& root) const
 {
     auto directories = doim::CxxIncludeDirectorySet::make();
@@ -150,40 +159,25 @@ doim::CxxIncludeDirectorySetSPtr CxxLibrary::indirectCxxIncludeDirectories(
     if (publicDirectory != nullptr)
         directories->insert(publicDirectory);
 
-    for (const auto& cxxLibrary : mCxxLibraries)
-    {
-        const auto& libDirectories = cxxLibrary->recursiveCxxIncludeDirectories(root);
-        directories->insert(libDirectories->begin(), libDirectories->end());
-    }
+    const auto& libDirectories = indirectPublicCxxIncludeDirectories(root);
+    directories->insert(libDirectories->begin(), libDirectories->end());
 
     return doim::CxxIncludeDirectorySet::unique(directories);
 }
 
-doim::CxxIncludeDirectorySetSPtr CxxLibrary::recursiveCxxIncludeDirectories(
+doim::CxxIncludeDirectorySetSPtr CxxLibrary::visibleCxxIncludeDirectories(
     const doim::FsDirectorySPtr& root) const
 {
-    auto fn = [this](doim::FsDirectorySPtr root,
-                     std::vector<dp::Handle::ControllerSPtr>& dependencies) {
-        auto directories = doim::CxxIncludeDirectorySet::make();
-
-        const auto& privateDirectory = cxxPrivateIncludeDirectory(root);
-        if (privateDirectory != nullptr)
-            directories->insert(privateDirectory);
-
-        const auto& publicDirectory = cxxPublicIncludeDirectory(root);
-        if (publicDirectory != nullptr)
-            directories->insert(publicDirectory);
+    auto directories = doim::CxxIncludeDirectorySet::make();
 
-        for (const auto& cxxLibrary : mCxxLibraries)
-        {
-            const auto& libDirectories = cxxLibrary->recursiveCxxIncludeDirectories(root);
-            directories->insert(libDirectories->begin(), libDirectories->end());
-        }
+    const auto& privateDirectory = cxxPrivateIncludeDirectory(root);
+    if (privateDirectory != nullptr)
+        directories->insert(privateDirectory);
 
-        return doim::CxxIncludeDirectorySet::unique(directories);
-    };
+    const auto& libDirectories = recursivePublicCxxIncludeDirectories(root);
+    directories->insert(libDirectories->begin(), libDirectories->end());
 
-    return mRecursiveCxxIncludeDirectoriesMemoization->get(mMemoizationHandle, root, fn);
+    return doim::CxxIncludeDirectorySet::unique(directories);
 }
 
 doim::CxxHeaderSetSPtr CxxLibrary::publicCxxHeaders(
@@ -197,7 +191,7 @@ doim::CxxHeaderSetSPtr CxxLibrary::publicCxxHeaders(
         return doim::CxxHeaderSet::unique(headers);
 
     auto type = cxxHeaderType();
-    const auto& directories = sublibraryCxxIncludeDirectories(root);
+    const auto& directories = indirectPublicCxxIncludeDirectories(root);
     for (const auto& header : *files)
     {
         auto cxxHeader = doim::CxxHeader::unique(type,
@@ -209,24 +203,7 @@ doim::CxxHeaderSetSPtr CxxLibrary::publicCxxHeaders(
     return doim::CxxHeaderSet::unique(headers);
 }
 
-doim::CxxHeaderSetSPtr CxxLibrary::indirectCxxHeaders(
-    const doim::FsDirectorySPtr& root) const
-{
-    auto headers = doim::CxxHeaderSet::make();
-
-    const auto& publicHeaders = publicCxxHeaders(root);
-    if (publicHeaders != nullptr)
-        headers->insert(publicHeaders->begin(), publicHeaders->end());
-
-    for (const auto& cxxLibrary : mCxxLibraries)
-    {
-        const auto& libHeaders = cxxLibrary->recursiveCxxHeaders(root);
-        headers->insert(libHeaders->begin(), libHeaders->end());
-    }
-    return doim::CxxHeaderSet::unique(headers);
-}
-
-doim::CxxHeaderSetSPtr CxxLibrary::recursiveCxxHeaders(
+doim::CxxHeaderSetSPtr CxxLibrary::recursivePublicCxxHeaders(
     const doim::FsDirectorySPtr& root) const
 {
     auto headers = doim::CxxHeaderSet::make();
@@ -235,21 +212,17 @@ doim::CxxHeaderSetSPtr CxxLibrary::recursiveCxxHeaders(
     if (publicHeaders != nullptr)
         headers->insert(publicHeaders->begin(), publicHeaders->end());
 
-    const auto& privateHeaders = privateCxxHeaders(root);
-    if (privateHeaders != nullptr)
-        headers->insert(privateHeaders->begin(), privateHeaders->end());
-
     for (const auto& cxxLibrary : mCxxLibraries)
     {
-        const auto& libHeaders = cxxLibrary->recursiveCxxHeaders(root);
+        const auto& libHeaders = cxxLibrary->recursivePublicCxxHeaders(root);
         headers->insert(libHeaders->begin(), libHeaders->end());
     }
     return doim::CxxHeaderSet::unique(headers);
 }
 
 void CxxLibrary::resetRecursiveCxxIncludeDirectoriesMemoization()
 {
-    auto memorization = mRecursiveCxxIncludeDirectoriesMemoization;
+    auto memorization = mIndirectPublicCxxIncludeDirectoriesMemoization;
     mMemoizationHandle = dp::Handle::create([memorization] { memorization->clear(); });
 }
 }

src/dom/cxx/cxx_library.h

@@ -87,20 +87,24 @@ class CxxLibrary : public Element<CxxLibrary>,
     doim::CxxIncludeDirectorySPtr cxxPublicIncludeDirectory(
         const doim::FsDirectorySPtr& root) const;
 
-    doim::CxxIncludeDirectorySetSPtr sublibraryCxxIncludeDirectories(
+    // Returns indirect include directories that can be used from objects of this library
+    doim::CxxIncludeDirectorySetSPtr indirectPublicCxxIncludeDirectories(
         const doim::FsDirectorySPtr& root) const;
 
-    doim::CxxIncludeDirectorySetSPtr indirectCxxIncludeDirectories(
+    // Returns direct and indirect include directories that can be used from objects
+    // that depend on this library
+    doim::CxxIncludeDirectorySetSPtr recursivePublicCxxIncludeDirectories(
         const doim::FsDirectorySPtr& root) const;
 
-    doim::CxxIncludeDirectorySetSPtr recursiveCxxIncludeDirectories(
+    // Returns direct and indirect include directories that objects from this library are
+    // able to see. This includes private and all depending public.
+    doim::CxxIncludeDirectorySetSPtr visibleCxxIncludeDirectories(
         const doim::FsDirectorySPtr& root) const;
 
     doim::CxxHeaderSetSPtr publicCxxHeaders(const doim::FsDirectorySPtr& root) const;
 
-    doim::CxxHeaderSetSPtr indirectCxxHeaders(const doim::FsDirectorySPtr& root) const;
-
-    doim::CxxHeaderSetSPtr recursiveCxxHeaders(const doim::FsDirectorySPtr& root) const;
+    doim::CxxHeaderSetSPtr recursivePublicCxxHeaders(
+        const doim::FsDirectorySPtr& root) const;
 
 private:
     EType mType;
@@ -119,6 +123,6 @@ class CxxLibrary : public Element<CxxLibrary>,
 
     dp::HandleSPtr mMemoizationHandle;
     RecursiveCxxIncludeDirectoriesMemoizationSPtr
-        mRecursiveCxxIncludeDirectoriesMemoization;
+        mIndirectPublicCxxIncludeDirectoriesMemoization;
 };
 }

src/dom/cxx/cxx_program.cpp

@@ -79,28 +79,18 @@ CxxLibrarySet CxxProgram::recursiveCxxLibraries() const
     return libraries;
 }
 
-doim::CxxIncludeDirectorySetSPtr CxxProgram::recursiveCxxIncludeDirectories(
+doim::CxxIncludeDirectorySetSPtr CxxProgram::visibleCxxIncludeDirectories(
     const doim::FsDirectorySPtr& root) const
 {
     auto directories = doim::CxxIncludeDirectorySet::make();
 
     for (const auto& cxxLibrary : mCxxLibraries)
     {
-        const auto& libDirectories = cxxLibrary->recursiveCxxIncludeDirectories(root);
+        const auto& libDirectories =
+            cxxLibrary->recursivePublicCxxIncludeDirectories(root);
         directories->insert(libDirectories->begin(), libDirectories->end());
     }
 
     return doim::CxxIncludeDirectorySet::unique(directories);
 }
-
-doim::CxxHeaderSetSPtr CxxProgram::cxxHeaders(const doim::FsDirectorySPtr& root) const
-{
-    auto headers = doim::CxxHeaderSet::make();
-    for (const auto& cxxLibrary : mCxxLibraries)
-    {
-        const auto& libHeaders = cxxLibrary->recursiveCxxHeaders(root);
-        headers->insert(libHeaders->begin(), libHeaders->end());
-    }
-    return doim::CxxHeaderSet::unique(headers);
-}
 }

src/dom/cxx/cxx_program.h

@@ -59,11 +59,9 @@ class CxxProgram : public Element<CxxProgram>,
 
     CxxLibrarySet recursiveCxxLibraries() const;
 
-    doim::CxxIncludeDirectorySetSPtr recursiveCxxIncludeDirectories(
+    doim::CxxIncludeDirectorySetSPtr visibleCxxIncludeDirectories(
         const doim::FsDirectorySPtr& root) const;
 
-    doim::CxxHeaderSetSPtr cxxHeaders(const doim::FsDirectorySPtr& root) const;
-
 private:
     string mName;
     CxxLibrarySet mCxxLibraries;

src/dom/dom.dbs

@@ -36,6 +36,11 @@ cxx_library dom-test
         ../err/err-test
 
         dom
+
+        # It is not so good that dom depepnds on parser. But this are just the tests.
+        # It does not seem reasanable to move them somewhere else just to avoid this ...
+        # and writing tests with parser is so much easier. 
+        ../parser/parser
     ;
 
     cxx_file:

src/dom/gtest/cxx_library-utest.cpp

@@ -2,15 +2,56 @@
 //
 
 #include "dom/cxx/cxx_library.h"
+#include "parser/dbs/dbs_parser.h"
 #include "doim/fs/fs_directory.h"
 #include "doim/fs/fs_file.h"
 #include "doim/set.hpp"
 #include "err/err.h"
 #include "err/gtest/err.h"
 #include "gtest/framework.h"
+#include "gtest/test_resource.h"
 #include <memory>
 #include <unordered>
 
+static void parse(string name)
+{
+    auto mDbsDirectory =
+        doim::FsDirectory::obtain(testing::gTestResourceDirectory, "dbs");
+    auto file = doim::FsFile::obtain(mDbsDirectory, name);
+
+    parser::DbsParser parser;
+    parser.parse(file);
+}
+
+TEST(CxxLibraryTest, SLOW_CxxLibraryHeaders)
+{
+    parse("cxx_library_headers.dbs");
+
+    auto mDbsDirectory =
+        doim::FsDirectory::obtain(testing::gTestResourceDirectory, "dbs");
+
+    auto cxxLibraryLib2Object = doim::Object::obtain(doim::Object::EType::kCxxLibrary,
+                                                     mDbsDirectory,
+                                                     "headers_lib2");
+
+    auto cxxLibraryLib2 = dom::CxxLibrary::find(cxxLibraryLib2Object);
+    ASSERT_NE(nullptr, cxxLibraryLib2);
+
+    const auto& publicHeaders = cxxLibraryLib2->publicCxxHeaders(mDbsDirectory);
+    ASSERT_EQ(1, publicHeaders->size());
+
+    const auto& recursivePublicHeaders =
+        cxxLibraryLib2->recursivePublicCxxHeaders(mDbsDirectory);
+    ASSERT_EQ(2, recursivePublicHeaders->size());
+
+    const auto& privateHeaders = cxxLibraryLib2->privateCxxHeaders(mDbsDirectory);
+    ASSERT_EQ(1, privateHeaders->size());
+
+    const auto& visibleDirectories =
+        cxxLibraryLib2->visibleCxxIncludeDirectories(mDbsDirectory);
+    ASSERT_EQ(3, visibleDirectories->size());
+}
+
 TEST(CxxLibraryTest, cxxLibraries)
 {
     dom::CxxLibrary library;
@@ -51,25 +92,3 @@ TEST(CxxLibraryTest, publicCxxHeaders)
     const auto& cxxIncludeDirectory = library.cxxPublicIncludeDirectory(directory);
     ASSERT_NE(nullptr, cxxIncludeDirectory);
 }
-
-TEST(CxxLibraryTest, recursiveCxxHeaders)
-{
-    dom::CxxLibrary library;
-
-    const auto& directory = doim::FsDirectory::obtain(nullptr, "/foo/include");
-
-    const auto& cxxHeaders1 = library.recursiveCxxHeaders(directory);
-    ASSERT_EQ(0U, cxxHeaders1->size());
-
-    doim::FsFileSet files;
-
-    const auto& file = doim::FsFile::obtain(directory, "header.h");
-    files.insert(file);
-
-    ASSERT_OKAY(library.updateCxxHeaders(doim::CxxHeader::EVisibility::kPublic,
-                                         directory,
-                                         files));
-
-    const auto& cxxHeaders2 = library.recursiveCxxHeaders(directory);
-    ASSERT_EQ(1U, cxxHeaders2->size());
-}