[ngcore] follow cpp guidelines, check them with clang-tidy

CMakeLists.txt

@@ -18,6 +18,7 @@ option( INSTALL_PROFILES "install environment variable settings to /etc/profile.
 option( USE_CCACHE       "use ccache")
 option( USE_INTERNAL_TCL "Compile tcl files into the code and don't install them" ON)
 option( ENABLE_UNIT_TESTS "Enable Catch unit tests")
+option( ENABLE_CPP_CORE_GUIDELINES_CHECK "Enable cpp core guideline checks on ngcore" OFF)
 
 option( USE_SUPERBUILD       "use ccache" ON)
 
@@ -349,6 +350,20 @@ endif(ENABLE_UNIT_TESTS)
 
 #######################################################################
 
+if(ENABLE_CPP_CORE_GUIDELINES_CHECK)
+  find_program(
+    CLANG_TIDY_EXE
+    NAMES "clang-tidy"
+    DOC "Path to clang-tidy executable"
+    )
+  if(NOT CLANG_TIDY_EXE)
+    message(WARNING "clang-tidy not found.")
+  else()
+    message(STATUS "clang-tidy found: ${CLANG_TIDY_EXE}")
+    set(DO_CLANG_TIDY "${CLANG_TIDY_EXE}" "-checks=*,-clang-analyzer-alpha.*,-*braces-around-statements,-fuchsia-default-arguments")
+  endif()
+endif(ENABLE_CPP_CORE_GUIDELINES_CHECK)
+
 add_subdirectory(libsrc)
 add_subdirectory(ng)
 add_subdirectory(tutorials)

cmake/SuperBuild.cmake

@@ -141,6 +141,7 @@ set_vars( NETGEN_CMAKE_ARGS
   CMAKE_PREFIX_PATH
   CMAKE_INSTALL_PREFIX
   ENABLE_UNIT_TESTS
+  ENABLE_CPP_CORE_GUIDELINES_CHECK
   )
 
 # propagate all variables set on the command line using cmake -DFOO=BAR

libsrc/core/CMakeLists.txt

@@ -1,10 +1,14 @@
-add_library(ngcore basearchive.cpp)
+
+add_library(ngcore archive.cpp version.cpp)
 
 set_target_properties(ngcore PROPERTIES POSITION_INDEPENDENT_CODE ON )
 target_compile_definitions(ngcore PRIVATE -DNGCORE_EXPORTS)
 
 install(TARGETS ngcore DESTINATION ${NG_INSTALL_DIR} COMPONENT netgen)
 
-install(FILES ngcore.hpp archive.hpp basearchive.hpp version.hpp type_traits.hpp
+install(FILES ngcore.hpp archive.hpp type_traits.hpp version.hpp ngcore_api.hpp
-  DESTINATION ${NG_INSTALL_DIR_INCLUDE}/core COMPONENT netgen_devel
+  DESTINATION ${NG_INSTALL_DIR_INCLUDE}/core COMPONENT netgen_devel)
-)
+
+if(ENABLE_CPP_CORE_GUIDELINES_CHECK)
+  set_target_properties(ngcore PROPERTIES CXX_CLANG_TIDY "${DO_CLANG_TIDY}")
+endif(ENABLE_CPP_CORE_GUIDELINES_CHECK)

libsrc/core/archive.cpp

@@ -0,0 +1,57 @@
+
+#include "archive.hpp"
+
+#ifndef WIN32
+#include <cxxabi.h>
+#endif
+
+namespace ngcore
+{
+  void VersionInfo :: DoArchive(Archive& ar)
+  {
+    ar & mayor_ & minor_ & release & patch & git_hash;
+  }
+
+  // clang-tidy should ignore this static object
+  static std::map<std::string, VersionInfo> library_versions;  // NOLINT
+  std::map<std::string, VersionInfo>& Archive :: GetLibraryVersions()
+  {
+    return library_versions;
+  }
+  const VersionInfo& GetLibraryVersion(const std::string& library)
+  { return library_versions[library]; }
+
+  void SetLibraryVersion(const std::string& library, const VersionInfo& version)
+  { library_versions[library] = version; }
+
+#ifdef WIN
+  // windows does demangling in typeid(T).name()
+  std::string demangle(const char* typeinfo) { return typeinfo; }
+#else
+  std::string demangle(const char* typeinfo) { int status; return abi::__cxa_demangle(typeinfo,
+                                                                                      nullptr,
+                                                                                      nullptr,
+                                                                                      &status); }
+#endif
+
+  // clang-tidy should ignore this static object
+  static std::unique_ptr<std::map<std::string, ClassArchiveInfo>> type_register;  // NOLINT
+  const ClassArchiveInfo& Archive :: GetArchiveRegister(const std::string& classname)
+  {
+    if(type_register == nullptr) type_register =
+                                   std::make_unique<std::map<std::string, ClassArchiveInfo>>();
+    return (*type_register)[classname];
+  }
+  void Archive :: SetArchiveRegister(const std::string& classname, const ClassArchiveInfo& info)
+  {
+    if(type_register == nullptr) type_register =
+                                   std::make_unique<std::map<std::string, ClassArchiveInfo>>();
+    (*type_register)[classname] = info;
+  }
+  bool Archive :: IsRegistered(const std::string& classname)
+  {
+    if(type_register == nullptr) type_register =
+                                   std::make_unique<std::map<std::string, ClassArchiveInfo>>();
+    return type_register->count(classname) != 0;
+  }
+} // namespace ngcore

libsrc/core/archive.hpp

@@ -1,8 +1,493 @@
-#ifndef NG_ARCHIVE_HPP
+#ifndef NETGEN_CORE_ARCHIVE_HPP
-#define NG_ARCHIVE_HPP
+#define NETGEN_CORE_ARCHIVE_HPP
+
+#include <complex>
+#include <cstring>
+#include <functional>
+#include <fstream>
+#include <iostream>
+#include <map>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "ngcore_api.hpp"
+#include "type_traits.hpp"
+#include "version.hpp"
 
 namespace ngcore
 {
+  // Libraries using this archive can store their version here to implement backwards compatibility
+  const VersionInfo& GetLibraryVersion(const std::string& library);
+  void SetLibraryVersion(const std::string& library, const VersionInfo& version);
+
+  class Archive;
+  NGCORE_API std::string demangle(const char* typeinfo);
+
+  // create new pointer of type T if it is default constructible, else throw
+  template<typename T>
+  T* constructIfPossible_impl(...)
+  { throw std::runtime_error(std::string(demangle(typeid(T).name())) + " is not default constructible!"); }
+
+  template<typename T, typename= typename std::enable_if<std::is_constructible<T>::value>::type>
+  T* constructIfPossible_impl(int) { return new T; }
+
+  template<typename T>
+  T* constructIfPossible() { return constructIfPossible_impl<T>(int{}); }
+
+  //Type trait to check if a class implements a 'void DoArchive(Archive&)' function
+  template<typename T>
+  struct has_DoArchive
+  {
+  private:
+    template<typename T2>
+    static constexpr auto check(T2*) ->
+      typename std::is_same<decltype(std::declval<T2>().DoArchive(std::declval<Archive&>())),void>::type;
+    template<typename>
+    static constexpr std::false_type check(...);
+    typedef decltype(check<T>(0)) type;
+  public:
+    NGCORE_API static constexpr bool value = type::value;
+  };
+
+  // Check if class is archivable
+  template<typename T>
+  struct is_Archivable
+  {
+  private:
+    template<typename T2>
+    static constexpr auto check(T2*) ->
+      typename std::is_same<decltype(std::declval<Archive>() & std::declval<T2&>()),Archive&>::type;
+    template<typename>
+    static constexpr std::false_type check(...);
+    typedef decltype(check<T>(nullptr)) type;
+  public:
+    NGCORE_API static constexpr bool value = type::value;
+  };
+
+  struct ClassArchiveInfo
+  {
+    // create new object of this type and return a void* pointer that is points to the location
+    // of the (base)class given by type_info
+    std::function<void*(const std::type_info&)> creator;
+    // This caster takes a void* pointer to the type stored in this info and casts it to a
+    // void* pointer pointing to the (base)class type_info
+    std::function<void*(const std::type_info&, void*)> upcaster;
+    // This caster takes a void* pointer to the (base)class type_info and returns void* pointing
+    // to the type stored in this info
+    std::function<void*(const std::type_info&, void*)> downcaster;
+  };
+
+  // Base Archive class
+  class NGCORE_API Archive
+  {
+    bool is_output;
+    // how many different shared_ptr/pointer have been (un)archived
+    int shared_ptr_count, ptr_count;
+    // maps for archived shared pointers and pointers
+    std::map<void*, int> shared_ptr2nr, ptr2nr;
+    // vectors for storing the unarchived (shared) pointers
+    std::vector<std::shared_ptr<void>> nr2shared_ptr;
+    std::vector<void*> nr2ptr;
+
+    // Helper class for up-/downcasting
+    template<typename T, typename ... Bases>
+    struct Caster
+    {
+      static void* tryUpcast(const std::type_info& ti, T* p);
+      static void* tryDowncast(const std::type_info& ti, void* p);
+    };
+    template<typename T, typename ... Bases>
+    friend class RegisterClassForArchive;
+
+    // Returns ClassArchiveInfo of demangled typeid
+    static const ClassArchiveInfo& GetArchiveRegister(const std::string& classname);
+    // Set ClassArchiveInfo for demangled typeid, this is done by creating an instance of
+    // RegisterClassForArchive<type, bases...>
+    static void SetArchiveRegister(const std::string& classname, const ClassArchiveInfo& info);
+    static bool IsRegistered(const std::string& classname);
+  public:
+    Archive (bool ais_output) : is_output(ais_output), shared_ptr_count(0), ptr_count(0) { ; }
+    virtual ~Archive() { ; }
+
+    bool Output () { return is_output; }
+    bool Input () { return !is_output; }
+    virtual const VersionInfo& getVersion(const std::string& library) = 0;
+
+    // Pure virtual functions that have to be implemented by In-/OutArchive
+    virtual Archive & operator & (double & d) = 0;
+    virtual Archive & operator & (int & i) = 0;
+    virtual Archive & operator & (long & i) = 0;
+    virtual Archive & operator & (size_t & i) = 0;
+    virtual Archive & operator & (short & i) = 0;
+    virtual Archive & operator & (unsigned char & i) = 0;
+    virtual Archive & operator & (bool & b) = 0;
+    virtual Archive & operator & (std::string & str) = 0;
+    virtual Archive & operator & (char *& str) = 0;
+
+
+    // Archive std classes ================================================
+    template<typename T>
+    Archive& operator & (std::complex<T>& c)
+    {
+      if(is_output)
+          (*this) << c.real() << c.imag();
+      else
+        {
+          T tmp;
+          (*this) & tmp;
+          c.real(tmp);
+          (*this) & tmp;
+          c.imag(tmp);
+        }
+      return (*this);
+    }
+    template<typename T>
+    Archive& operator & (std::vector<T>& v)
+    {
+      size_t size;
+      if(is_output)
+          size = v.size();
+      (*this) & size;
+      if(!is_output)
+        v.resize(size);
+      Do(&v[0], size);
+      return (*this);
+    }
+    template<typename T1, typename T2>
+    Archive& operator& (std::map<T1, T2>& map)
+    {
+      if(is_output)
+        {
+          (*this) << size_t(map.size());
+          for(auto& pair : map)
+              (*this) << pair.first << pair.second;
+        }
+      else
+        {
+          size_t size;
+          (*this) & size;
+          T1 key; T2 val;
+          for(size_t i = 0; i < size; i++)
+            {
+              T1 key; T2 val;
+              (*this) & key & val;
+              map[key] = val;
+            }
+        }
+      return (*this);
+    }
+    // Archive arrays =====================================================
+    // this functions can be overloaded in Archive implementations for more efficiency
+    template <typename T, typename = typename std::enable_if<is_Archivable<T>::value>::type>
+    Archive & Do (T * data, size_t n)
+    { for (size_t j = 0; j < n; j++) { (*this) & data[j]; }; return *this; };
+
+    virtual Archive & Do (double * d, size_t n)
+    { for (size_t j = 0; j < n; j++) { (*this) & d[j]; }; return *this; };
+
+    virtual Archive & Do (int * i, size_t n)
+    { for (size_t j = 0; j < n; j++) { (*this) & i[j]; }; return *this; };
+
+    virtual Archive & Do (long * i, size_t n)
+    { for (size_t j = 0; j < n; j++) { (*this) & i[j]; }; return *this; };
+
+    virtual Archive & Do (size_t * i, size_t n)
+    { for (size_t j = 0; j < n; j++) { (*this) & i[j]; }; return *this; };
+
+    virtual Archive & Do (short * i, size_t n)
+    { for (size_t j = 0; j < n; j++) { (*this) & i[j]; }; return *this; };
+
+    virtual Archive & Do (unsigned char * i, size_t n)
+    { for (size_t j = 0; j < n; j++) { (*this) & i[j]; }; return *this; };
+
+    virtual Archive & Do (bool * b, size_t n)
+    { for (size_t j = 0; j < n; j++) { (*this) & b[j]; }; return *this; };
+
+    // Archive a class implementing a (void DoArchive(Archive&)) method =======
+    template<typename T, typename=std::enable_if_t<has_DoArchive<T>::value>>
+    Archive& operator & (T& val)
+    {
+      val.DoArchive(*this); return *this;
+    }
+
+    // Archive shared_ptrs =================================================
+    template <typename T>
+    Archive& operator & (std::shared_ptr<T>& ptr)
+    {
+      if(Output())
+        {
+          // save -2 for nullptr
+          if(!ptr)
+            return (*this) << -2;
+
+          void* reg_ptr = ptr.get();
+          bool neededDowncast = false;
+          // Downcasting is only possible for our registered classes
+          if(typeid(T) != typeid(*ptr))
+            {
+              if(!IsRegistered(demangle(typeid(*ptr).name())))
+                  throw std::runtime_error(std::string("Archive error: Polymorphic type ")
+                                           + demangle(typeid(*ptr).name())
+                                           + " not registered for archive");
+              reg_ptr = GetArchiveRegister(demangle(typeid(*ptr).name())).downcaster(typeid(T), ptr.get());
+              // if there was a true downcast we have to store more information
+              if(reg_ptr != (void*) ptr.get())
+                  neededDowncast = true;
+            }
+          auto pos = shared_ptr2nr.find(reg_ptr);
+          // if not found store -1 and the pointer
+          if(pos == shared_ptr2nr.end())
+            {
+              auto p = ptr.get();
+              (*this) << -1;
+              (*this) & neededDowncast & p;
+              // if we did downcast we store the true type as well
+              if(neededDowncast)
+                (*this) << demangle(typeid(*ptr).name());
+              shared_ptr2nr[reg_ptr] = shared_ptr_count++;
+              return *this;
+            }
+          // if found store the position and if it has to be downcasted and how
+          (*this) << pos->second << neededDowncast;
+          if(neededDowncast)
+            (*this) << demangle(typeid(*ptr).name());
+          return (*this);
+        }
+      else // Input
+        {
+          int nr;
+          (*this) & nr;
+          // -2 restores a nullptr
+          if(nr == -2)
+            {
+              ptr = nullptr;
+              return *this;
+            }
+          // -1 restores a new shared ptr by restoring the inner pointer and creating a shared_ptr to it
+          else if (nr == -1)
+            {
+              T* p;
+              bool neededDowncast;
+              (*this) & neededDowncast & p;
+              ptr = std::shared_ptr<T>(p);
+              // if we did downcast we need to store a shared_ptr<void> to the true object
+              if(neededDowncast)
+                {
+                  std::string name;
+                  (*this) & name;
+                  auto info = GetArchiveRegister(name);
+                  // for this we use an aliasing constructor to create a shared pointer sharing lifetime
+                  // with our shared ptr, but pointing to the true object
+                  nr2shared_ptr.push_back(std::shared_ptr<void>(std::static_pointer_cast<void>(ptr),
+                                                                info.downcaster(typeid(T),
+                                                                                ptr.get())));
+                }
+              else
+                nr2shared_ptr.push_back(ptr);
+            }
+          else
+            {
+              auto other = nr2shared_ptr[nr];
+              bool neededDowncast;
+              (*this) & neededDowncast;
+              if(neededDowncast)
+                {
+                  // if there was a downcast we can expect the class to be registered (since archiving
+                  // wouldn't have worked else)
+                  std::string name;
+                  (*this) & name;
+                  auto info = GetArchiveRegister(name);
+                  // same trick as above, create a shared ptr sharing lifetime with
+                  // the shared_ptr<void> in the register, but pointing to our object
+                  ptr = std::static_pointer_cast<T>(std::shared_ptr<void>(other,
+                                                                          info.upcaster(typeid(T),
+                                                                               other.get())));
+                }
+              else
+                ptr = std::static_pointer_cast<T>(other);
+            }
+        }
+      return *this;
+    }
+
+    // Archive pointers =======================================================
+    template <typename T>
+    Archive & operator& (T *& p)
+    {
+      if (Output())
+        {
+          // if the pointer is null store -2
+          if (!p)
+            return (*this) << -2;
+          void* reg_ptr = (void*)p;
+          if(typeid(T) != typeid(*p))
+            {
+              if(!IsRegistered(demangle(typeid(*p).name())))
+                throw std::runtime_error(std::string("Archive error: Polymorphic type ")
+                                         + demangle(typeid(*p).name())
+                                         + " not registered for archive");
+              else
+                reg_ptr = GetArchiveRegister(demangle(typeid(*p).name())).downcaster(typeid(T), (void*) p);
+            }
+          auto pos = ptr2nr.find(reg_ptr);
+          // if the pointer is not found in the map create a new entry
+          if (pos == ptr2nr.end())
+            {
+              ptr2nr[reg_ptr] = ptr_count++;
+              if(typeid(*p) == typeid(T))
+                if (std::is_constructible<T>::value)
+                               {
+                                 return (*this) << -1 & (*p);
+                               }
+                else
+                  throw std::runtime_error(std::string("Archive error: Class ") +
+                                           demangle(typeid(*p).name()) + " does not provide a default constructor!");
+              else
+                {
+                  // if a pointer to a base class is archived, the class hierarchy must be registered
+                  // to avoid compile time issues we allow this behaviour only for "our" classes that
+                  // implement a void DoArchive(Archive&) member function
+                  // To recreate the object we need to store the true type of it
+                  if(!IsRegistered(demangle(typeid(*p).name())))
+                    throw std::runtime_error(std::string("Archive error: Polymorphic type ")
+                                             + demangle(typeid(*p).name())
+                                             + " not registered for archive");
+                  else
+                    return (*this) << -3 << demangle(typeid(*p).name()) & (*p);
+                }
+            }
+          else
+            {
+              (*this) & pos->second;
+              bool downcasted = !(reg_ptr == (void*) p);
+              // store if the class has been downcasted and the name
+              (*this) << downcasted << demangle(typeid(*p).name());
+            }
+        }
+      else
+        {
+          int nr;
+          (*this) & nr;
+          if (nr == -2) // restore a nullptr
+              p = nullptr;
+          else if (nr == -1) // create a new pointer of standard type (no virtual or multiple inheritance,...)
+            {
+              p = constructIfPossible<T>();
+              nr2ptr.push_back(p);
+              (*this) & *p;
+            }
+          else if(nr == -3) // restore one of our registered classes that can have multiple inheritance,...
+            {
+              // As stated above, we want this special behaviour only for our classes that implement DoArchive
+              std::string name;
+              (*this) & name;
+              auto info = GetArchiveRegister(name);
+              // the creator creates a new object of type name, and returns a void* pointing
+              // to T (which may have an offset)
+              p = (T*) info.creator(typeid(T));
+              // we store the downcasted pointer (to be able to find it again from
+              // another class in a multiple inheritance tree)
+              nr2ptr.push_back(info.downcaster(typeid(T),p));
+              (*this) & *p;
+            }
+          else
+            {
+              bool downcasted;
+              std::string name;
+              (*this) & downcasted & name;
+              if(downcasted)
+                {
+                  // if the class has been downcasted we can assume it is in the register
+                  auto info = GetArchiveRegister(name);
+                  p = (T*) info.upcaster(typeid(T), nr2ptr[nr]);
+                }
+              else
+                p = (T*) nr2ptr[nr];
+            }
+        }
+      return *this;
+    }
+
+    // const ptr
+    template<typename T>
+    Archive& operator &(const T*& t)
+    {
+      return (*this) & const_cast<T*&>(t);
+    }
+
+    // Write a read only variable
+    template <typename T>
+    Archive & operator << (const T & t)
+    {
+      T ht(t);
+      (*this) & ht;
+      return *this;
+    }
+
+    virtual void FlushBuffer() {}
+
+  protected:
+    static std::map<std::string, VersionInfo>& GetLibraryVersions();
+  private:
+    template<typename T>
+    struct Caster<T>
+    {
+      static void* tryUpcast (const std::type_info& ti, T* p)
+      {
+        throw std::runtime_error("Upcast not successful, some classes are not registered properly for archiving!");
+      }
+      static void* tryDowncast (const std::type_info& ti, void* p)
+      {
+        throw std::runtime_error("Downcast not successful, some classes are not registered properly for archiving!");
+      }
+    };
+
+    template<typename T, typename B1, typename ... Brest>
+    struct Caster<T,B1,Brest...>
+    {
+      static void* tryUpcast(const std::type_info& ti, T* p)
+      {
+        try
+          { return GetArchiveRegister(demangle(typeid(B1).name())).upcaster(ti, (void*) (dynamic_cast<B1*>(p))); }
+        catch(std::exception)
+          { return Caster<T, Brest...>::tryUpcast(ti, p); }
+      }
+
+      static void* tryDowncast(const std::type_info& ti, void* p)
+      {
+        if(typeid(B1) == ti)
+          return dynamic_cast<T*>((B1*) p);
+        try
+          { return GetArchiveRegister(demangle(typeid(B1).name())).downcaster(ti, (void*) ((B1*)p)); }
+        catch(std::exception)
+          { return Caster<T, Brest...>::tryDowncast(ti, p); }
+      }
+    };
+  };
+
+  template<typename T, typename ... Bases>
+  class NGCORE_API RegisterClassForArchive
+  {
+  public:
+    RegisterClassForArchive()
+    {
+      static_assert(all_of_tmpl<std::is_base_of<Bases,T>::value...>,
+                    "Variadic template arguments must be base classes of T");
+      ClassArchiveInfo info;
+      info.creator = [this,&info](const std::type_info& ti) -> void*
+                     { return typeid(T) == ti ? constructIfPossible<T>()
+                         : Archive::Caster<T, Bases...>::tryUpcast(ti, constructIfPossible<T>()); };
+      info.upcaster = [this](const std::type_info& ti, void* p) -> void*
+                      { return typeid(T) == ti ? p : Archive::Caster<T, Bases...>::tryUpcast(ti, (T*) p); };
+      info.downcaster = [this](const std::type_info& ti, void* p) -> void*
+                        { return typeid(T) == ti ? p : Archive::Caster<T, Bases...>::tryDowncast(ti, p); };
+      Archive::SetArchiveRegister(std::string(demangle(typeid(T).name())),info);
+    }
+
+
+  };
+
   // BinaryOutArchive ======================================================================
   class NGCORE_API BinaryOutArchive : public Archive
   {
@@ -159,7 +644,7 @@ namespace ngcore
       (*this) & GetLibraryVersions();
     }
     TextOutArchive (std::string filename) :
-      TextOutArchive(std::make_shared<std::ofstream>(filename.c_str())) { }
+      TextOutArchive(std::make_shared<std::ofstream>(filename)) { }
 
     const VersionInfo& getVersion(const std::string& library)
     { return GetLibraryVersions()[library]; }
@@ -265,5 +750,6 @@ namespace ngcore
       return *this;
     }
   };
-}
+} // namespace ngcore
-#endif // NG_ARCHIVE_HPP
+
+#endif // NETGEN_CORE_ARCHIVE_HPP

libsrc/core/basearchive.cpp

@@ -1,44 +0,0 @@
-
-#include "ngcore.hpp"
-
-#ifndef WIN
-#include <cxxabi.h>
-#endif
-
-namespace ngcore
-{
-  static std::map<std::string, VersionInfo> library_versions;
-  std::map<std::string, VersionInfo>& Archive :: GetLibraryVersions()
-  {
-    return library_versions;
-  }
-  VersionInfo GetLibraryVersion(const std::string& library)
-  { return library_versions[library]; }
-
-  void SetLibraryVersion(const std::string& library, VersionInfo version)
-  { library_versions[library] = version; }
-
-#ifdef WIN
-  // windows does demangling in typeid(T).name()
-  std::string demangle(const char* typeinfo) { return typeinfo; }
-#else
-  std::string demangle(const char* typeinfo) { int status; return abi::__cxa_demangle(typeinfo, 0, 0, &status); }
-#endif
-
-  static std::map<std::string, ClassArchiveInfo>* type_register;
-  const ClassArchiveInfo& Archive :: GetArchiveRegister(const std::string& classname)
-  {
-    if(!type_register) type_register = new std::map<std::string, ClassArchiveInfo>();
-    return (*type_register)[classname];
-  }
-  void Archive :: SetArchiveRegister(const std::string& classname, ClassArchiveInfo info)
-  {
-    if(!type_register) type_register = new std::map<std::string, ClassArchiveInfo>();
-    (*type_register)[classname] = info;
-  }
-  bool Archive :: IsRegistered(const std::string& classname)
-  {
-    if(!type_register) type_register = new std::map<std::string, ClassArchiveInfo>();
-    return type_register->count(classname) != 0;
-  }
-}

libsrc/core/basearchive.hpp

@@ -1,480 +0,0 @@
-#ifndef NG_BASEARCHIVE_HPP
-#define NG_BASEARCHIVE_HPP
-
-namespace ngcore
-{
-  class VersionInfo;
-  // Libraries using this archive can store their version here to implement backwards compatibility
-  VersionInfo GetLibraryVersion(const std::string& library);
-  void SetLibraryVersion(const std::string& library, VersionInfo version);
-
-  class Archive;
-  NGCORE_API std::string demangle(const char* typeinfo);
-
-  // create new pointer of type T if it is default constructible, else throw
-  template<typename T>
-  T* constructIfPossible_impl(...)
-  { throw std::runtime_error(std::string(demangle(typeid(T).name())) + " is not default constructible!"); }
-
-  template<typename T, typename= typename std::enable_if<std::is_constructible<T>::value>::type>
-  T* constructIfPossible_impl(int) { return new T; }
-
-  template<typename T>
-  T* constructIfPossible() { return constructIfPossible_impl<T>(int{}); }
-
-  //Type trait to check if a class implements a 'void DoArchive(Archive&)' function
-  template<typename T>
-  struct has_DoArchive
-  {
-  private:
-    template<typename T2>
-    static constexpr auto check(T2*) ->
-      typename std::is_same<decltype(std::declval<T2>().DoArchive(std::declval<Archive&>())),void>::type;
-    template<typename>
-    static constexpr std::false_type check(...);
-    typedef decltype(check<T>(0)) type;
-  public:
-    NGCORE_API static constexpr bool value = type::value;
-  };
-
-  // Check if class is archivable
-  template<typename T>
-  struct is_Archivable
-  {
-  private:
-    template<typename T2>
-    static constexpr auto check(T2*) ->
-      typename std::is_same<decltype(std::declval<Archive>() & std::declval<T2&>()),Archive&>::type;
-    template<typename>
-    static constexpr std::false_type check(...);
-    typedef decltype(check<T>(nullptr)) type;
-  public:
-    NGCORE_API static constexpr bool value = type::value;
-  };
-
-  struct ClassArchiveInfo
-  {
-    // create new object of this type and return a void* pointer that is points to the location
-    // of the (base)class given by type_info
-    std::function<void*(const std::type_info&)> creator;
-    // This caster takes a void* pointer to the type stored in this info and casts it to a
-    // void* pointer pointing to the (base)class type_info
-    std::function<void*(const std::type_info&, void*)> upcaster;
-    // This caster takes a void* pointer to the (base)class type_info and returns void* pointing
-    // to the type stored in this info
-    std::function<void*(const std::type_info&, void*)> downcaster;
-  };
-
-  // Base Archive class
-  class NGCORE_API Archive
-  {
-    bool is_output;
-    // how many different shared_ptr/pointer have been (un)archived
-    int shared_ptr_count, ptr_count;
-    // maps for archived shared pointers and pointers
-    std::map<void*, int> shared_ptr2nr, ptr2nr;
-    // vectors for storing the unarchived (shared) pointers
-    std::vector<std::shared_ptr<void>> nr2shared_ptr;
-    std::vector<void*> nr2ptr;
-
-    // Helper class for up-/downcasting
-    template<typename T, typename ... Bases>
-    struct Caster
-    {
-      static void* tryUpcast(const std::type_info& ti, T* p);
-      static void* tryDowncast(const std::type_info& ti, void* p);
-    };
-    template<typename T, typename ... Bases>
-    friend class RegisterClassForArchive;
-
-    // Returns ClassArchiveInfo of demangled typeid
-    static const ClassArchiveInfo& GetArchiveRegister(const std::string& classname);
-    // Set ClassArchiveInfo for demangled typeid, this is done by creating an instance of
-    // RegisterClassForArchive<type, bases...>
-    static void SetArchiveRegister(const std::string& classname, ClassArchiveInfo info);
-    static bool IsRegistered(const std::string& classname);
-  public:
-    Archive (bool ais_output) : is_output(ais_output), shared_ptr_count(0), ptr_count(0) { ; }
-    virtual ~Archive() { ; }
-
-    bool Output () { return is_output; }
-    bool Input () { return !is_output; }
-    virtual const VersionInfo& getVersion(const std::string& library) = 0;
-
-    // Pure virtual functions that have to be implemented by In-/OutArchive
-    virtual Archive & operator & (double & d) = 0;
-    virtual Archive & operator & (int & i) = 0;
-    virtual Archive & operator & (long & i) = 0;
-    virtual Archive & operator & (size_t & i) = 0;
-    virtual Archive & operator & (short & i) = 0;
-    virtual Archive & operator & (unsigned char & i) = 0;
-    virtual Archive & operator & (bool & b) = 0;
-    virtual Archive & operator & (std::string & str) = 0;
-    virtual Archive & operator & (char *& str) = 0;
-
-
-    // Archive std classes ================================================
-    template<typename T>
-    Archive& operator & (std::complex<T>& c)
-    {
-      if(is_output)
-          (*this) << c.real() << c.imag();
-      else
-        {
-          T tmp;
-          (*this) & tmp;
-          c.real(tmp);
-          (*this) & tmp;
-          c.imag(tmp);
-        }
-      return (*this);
-    }
-    template<typename T>
-    Archive& operator & (std::vector<T>& v)
-    {
-      size_t size;
-      if(is_output)
-          size = v.size();
-      (*this) & size;
-      if(!is_output)
-        v.resize(size);
-      Do(&v[0], size);
-      return (*this);
-    }
-    template<typename T1, typename T2>
-    Archive& operator& (std::map<T1, T2>& map)
-    {
-      if(is_output)
-        {
-          (*this) << size_t(map.size());
-          for(auto& pair : map)
-              (*this) << pair.first << pair.second;
-        }
-      else
-        {
-          size_t size;
-          (*this) & size;
-          T1 key; T2 val;
-          for(size_t i = 0; i < size; i++)
-            {
-              T1 key; T2 val;
-              (*this) & key & val;
-              map[key] = val;
-            }
-        }
-      return (*this);
-    }
-    // Archive arrays =====================================================
-    // this functions can be overloaded in Archive implementations for more efficiency
-    template <typename T, typename = typename std::enable_if<is_Archivable<T>::value>::type>
-    Archive & Do (T * data, size_t n)
-    { for (size_t j = 0; j < n; j++) { (*this) & data[j]; }; return *this; };
-
-    virtual Archive & Do (double * d, size_t n)
-    { for (size_t j = 0; j < n; j++) { (*this) & d[j]; }; return *this; };
-
-    virtual Archive & Do (int * i, size_t n)
-    { for (size_t j = 0; j < n; j++) { (*this) & i[j]; }; return *this; };
-
-    virtual Archive & Do (long * i, size_t n)
-    { for (size_t j = 0; j < n; j++) { (*this) & i[j]; }; return *this; };
-
-    virtual Archive & Do (size_t * i, size_t n)
-    { for (size_t j = 0; j < n; j++) { (*this) & i[j]; }; return *this; };
-
-    virtual Archive & Do (short * i, size_t n)
-    { for (size_t j = 0; j < n; j++) { (*this) & i[j]; }; return *this; };
-
-    virtual Archive & Do (unsigned char * i, size_t n)
-    { for (size_t j = 0; j < n; j++) { (*this) & i[j]; }; return *this; };
-
-    virtual Archive & Do (bool * b, size_t n)
-    { for (size_t j = 0; j < n; j++) { (*this) & b[j]; }; return *this; };
-
-    // Archive a class implementing a (void DoArchive(Archive&)) method =======
-    template<typename T, typename=std::enable_if_t<has_DoArchive<T>::value>>
-    Archive& operator & (T& val)
-    {
-      val.DoArchive(*this); return *this;
-    }
-
-    // Archive shared_ptrs =================================================
-    template <typename T>
-    Archive& operator & (std::shared_ptr<T>& ptr)
-    {
-      if(Output())
-        {
-          // save -2 for nullptr
-          if(!ptr)
-            return (*this) << -2;
-
-          void* reg_ptr = ptr.get();
-          bool neededDowncast = false;
-          // Downcasting is only possible for our registered classes
-          if(typeid(T) != typeid(*ptr))
-            {
-              if(!IsRegistered(demangle(typeid(*ptr).name())))
-                  throw std::runtime_error(std::string("Archive error: Polymorphic type ")
-                                           + demangle(typeid(*ptr).name())
-                                           + " not registered for archive");
-              reg_ptr = GetArchiveRegister(demangle(typeid(*ptr).name())).downcaster(typeid(T), ptr.get());
-              // if there was a true downcast we have to store more information
-              if(reg_ptr != (void*) ptr.get())
-                  neededDowncast = true;
-            }
-          auto pos = shared_ptr2nr.find(reg_ptr);
-          // if not found store -1 and the pointer
-          if(pos == shared_ptr2nr.end())
-            {
-              auto p = ptr.get();
-              (*this) << -1;
-              (*this) & neededDowncast & p;
-              // if we did downcast we store the true type as well
-              if(neededDowncast)
-                (*this) << demangle(typeid(*ptr).name());
-              shared_ptr2nr[reg_ptr] = shared_ptr_count++;
-              return *this;
-            }
-          // if found store the position and if it has to be downcasted and how
-          (*this) << pos->second << neededDowncast;
-          if(neededDowncast)
-            (*this) << demangle(typeid(*ptr).name());
-          return (*this);
-        }
-      else // Input
-        {
-          int nr;
-          (*this) & nr;
-          // -2 restores a nullptr
-          if(nr == -2)
-            {
-              ptr = nullptr;
-              return *this;
-            }
-          // -1 restores a new shared ptr by restoring the inner pointer and creating a shared_ptr to it
-          else if (nr == -1)
-            {
-              T* p;
-              bool neededDowncast;
-              (*this) & neededDowncast & p;
-              ptr = std::shared_ptr<T>(p);
-              // if we did downcast we need to store a shared_ptr<void> to the true object
-              if(neededDowncast)
-                {
-                  std::string name;
-                  (*this) & name;
-                  auto info = GetArchiveRegister(name);
-                  // for this we use an aliasing constructor to create a shared pointer sharing lifetime
-                  // with our shared ptr, but pointing to the true object
-                  nr2shared_ptr.push_back(std::shared_ptr<void>(std::static_pointer_cast<void>(ptr),
-                                                                info.downcaster(typeid(T),
-                                                                                ptr.get())));
-                }
-              else
-                nr2shared_ptr.push_back(ptr);
-            }
-          else
-            {
-              auto other = nr2shared_ptr[nr];
-              bool neededDowncast;
-              (*this) & neededDowncast;
-              if(neededDowncast)
-                {
-                  // if there was a downcast we can expect the class to be registered (since archiving
-                  // wouldn't have worked else)
-                  std::string name;
-                  (*this) & name;
-                  auto info = GetArchiveRegister(name);
-                  // same trick as above, create a shared ptr sharing lifetime with
-                  // the shared_ptr<void> in the register, but pointing to our object
-                  ptr = std::static_pointer_cast<T>(std::shared_ptr<void>(other,
-                                                                          info.upcaster(typeid(T),
-                                                                               other.get())));
-                }
-              else
-                ptr = std::static_pointer_cast<T>(other);
-            }
-        }
-      return *this;
-    }
-
-    // Archive pointers =======================================================
-    template <typename T>
-    Archive & operator& (T *& p)
-    {
-      if (Output())
-        {
-          // if the pointer is null store -2
-          if (!p)
-            return (*this) << -2;
-          void* reg_ptr = (void*)p;
-          if(typeid(T) != typeid(*p))
-            {
-              if(!IsRegistered(demangle(typeid(*p).name())))
-                throw std::runtime_error(std::string("Archive error: Polymorphic type ")
-                                         + demangle(typeid(*p).name())
-                                         + " not registered for archive");
-              else
-                reg_ptr = GetArchiveRegister(demangle(typeid(*p).name())).downcaster(typeid(T), (void*) p);
-            }
-          auto pos = ptr2nr.find(reg_ptr);
-          // if the pointer is not found in the map create a new entry
-          if (pos == ptr2nr.end())
-            {
-              ptr2nr[reg_ptr] = ptr_count++;
-              if(typeid(*p) == typeid(T))
-                if (std::is_constructible<T>::value)
-                               {
-                                 return (*this) << -1 & (*p);
-                               }
-                else
-                  throw std::runtime_error(std::string("Archive error: Class ") +
-                                           demangle(typeid(*p).name()) + " does not provide a default constructor!");
-              else
-                {
-                  // if a pointer to a base class is archived, the class hierarchy must be registered
-                  // to avoid compile time issues we allow this behaviour only for "our" classes that
-                  // implement a void DoArchive(Archive&) member function
-                  // To recreate the object we need to store the true type of it
-                  if(!IsRegistered(demangle(typeid(*p).name())))
-                    throw std::runtime_error(std::string("Archive error: Polymorphic type ")
-                                             + demangle(typeid(*p).name())
-                                             + " not registered for archive");
-                  else
-                    return (*this) << -3 << demangle(typeid(*p).name()) & (*p);
-                }
-            }
-          else
-            {
-              (*this) & pos->second;
-              bool downcasted = !(reg_ptr == (void*) p);
-              // store if the class has been downcasted and the name
-              (*this) << downcasted << demangle(typeid(*p).name());
-            }
-        }
-      else
-        {
-          int nr;
-          (*this) & nr;
-          if (nr == -2) // restore a nullptr
-              p = nullptr;
-          else if (nr == -1) // create a new pointer of standard type (no virtual or multiple inheritance,...)
-            {
-              p = constructIfPossible<T>();
-              nr2ptr.push_back(p);
-              (*this) & *p;
-            }
-          else if(nr == -3) // restore one of our registered classes that can have multiple inheritance,...
-            {
-              // As stated above, we want this special behaviour only for our classes that implement DoArchive
-              std::string name;
-              (*this) & name;
-              auto info = GetArchiveRegister(name);
-              // the creator creates a new object of type name, and returns a void* pointing
-              // to T (which may have an offset)
-              p = (T*) info.creator(typeid(T));
-              // we store the downcasted pointer (to be able to find it again from
-              // another class in a multiple inheritance tree)
-              nr2ptr.push_back(info.downcaster(typeid(T),p));
-              (*this) & *p;
-            }
-          else
-            {
-              bool downcasted;
-              std::string name;
-              (*this) & downcasted & name;
-              if(downcasted)
-                {
-                  // if the class has been downcasted we can assume it is in the register
-                  auto info = GetArchiveRegister(name);
-                  p = (T*) info.upcaster(typeid(T), nr2ptr[nr]);
-                }
-              else
-                p = (T*) nr2ptr[nr];
-            }
-        }
-      return *this;
-    }
-
-    // const ptr
-    template<typename T>
-    Archive& operator &(const T*& t)
-    {
-      return (*this) & const_cast<T*&>(t);
-    }
-
-    // Write a read only variable
-    template <typename T>
-    Archive & operator << (const T & t)
-    {
-      T ht(t);
-      (*this) & ht;
-      return *this;
-    }
-
-    virtual void FlushBuffer() {}
-
-  protected:
-    static std::map<std::string, VersionInfo>& GetLibraryVersions();
-  private:
-    template<typename T>
-    struct Caster<T>
-    {
-      static void* tryUpcast (const std::type_info& ti, T* p)
-      {
-        throw std::runtime_error("Upcast not successful, some classes are not registered properly for archiving!");
-      }
-      static void* tryDowncast (const std::type_info& ti, void* p)
-      {
-        throw std::runtime_error("Downcast not successful, some classes are not registered properly for archiving!");
-      }
-    };
-
-    template<typename T, typename B1, typename ... Brest>
-    struct Caster<T,B1,Brest...>
-    {
-      static void* tryUpcast(const std::type_info& ti, T* p)
-      {
-        try
-          { return GetArchiveRegister(demangle(typeid(B1).name())).upcaster(ti, (void*) (dynamic_cast<B1*>(p))); }
-        catch(std::exception)
-          { return Caster<T, Brest...>::tryUpcast(ti, p); }
-      }
-
-      static void* tryDowncast(const std::type_info& ti, void* p)
-      {
-        if(typeid(B1) == ti)
-          return dynamic_cast<T*>((B1*) p);
-        try
-          { return GetArchiveRegister(demangle(typeid(B1).name())).downcaster(ti, (void*) ((B1*)p)); }
-        catch(std::exception)
-          { return Caster<T, Brest...>::tryDowncast(ti, p); }
-      }
-    };
-  };
-
-  template<typename T, typename ... Bases>
-  class NGCORE_API RegisterClassForArchive
-  {
-  public:
-    RegisterClassForArchive()
-    {
-      static_assert(all_of_tmpl<std::is_base_of<Bases,T>::value...>,
-                    "Variadic template arguments must be base classes of T");
-      ClassArchiveInfo info;
-      info.creator = [this,&info](const std::type_info& ti) -> void*
-                     { return typeid(T) == ti ? constructIfPossible<T>()
-                         : Archive::Caster<T, Bases...>::tryUpcast(ti, constructIfPossible<T>()); };
-      info.upcaster = [this](const std::type_info& ti, void* p) -> void*
-                      { return typeid(T) == ti ? p : Archive::Caster<T, Bases...>::tryUpcast(ti, (T*) p); };
-      info.downcaster = [this](const std::type_info& ti, void* p) -> void*
-                        { return typeid(T) == ti ? p : Archive::Caster<T, Bases...>::tryDowncast(ti, p); };
-      Archive::SetArchiveRegister(std::string(demangle(typeid(T).name())),info);
-    }
-
-
-  };
-
-}
-
-#endif // NG_BASEARCHIVE_HPP

libsrc/core/ngcore.hpp

@@ -1,49 +1,7 @@
-#ifndef NG_CORE_HPP
+#ifndef NETGEN_CORE_NGCORE_HPP
-#define NG_CORE_HPP
+#define NETGEN_CORE_NGCORE_HPP
 
-// std includes
-#include <memory>
-#include <string>
-#include <vector>
-#include <map>
-#include <iterator>
-#include <type_traits>
-#include <functional>
-#include <stdexcept>
-#include <iostream>
-#include <fstream>
-#include <cstring>
-#include <complex>
-
-#ifdef WIN32
-        #define NGCORE_API_EXPORT __declspec(dllexport)
-        #define NGCORE_API_IMPORT __declspec(dllimport)
-#else
-        #define NGCORE_API_EXPORT
-        #define NGCORE_API_IMPORT
-#endif
-
-#ifdef NGCORE_EXPORTS
-        #define NGCORE_API NGCORE_API_EXPORT
-#else
-        #define NGCORE_API NGCORE_API_IMPORT
-#endif
-
-namespace ngcore
-{
-#if defined(__GNUC__)
-  inline bool likely (bool x) { return __builtin_expect((x), true); }
-  inline bool unlikely (bool x) { return __builtin_expect((x), false); }
-#else
-  inline bool likely (bool x) { return x; }
-  inline bool unlikely (bool x) { return x; }
-#endif
-}
-
-// own includes
-#include "type_traits.hpp"
-#include "basearchive.hpp"
-#include "version.hpp"
 #include "archive.hpp"
+#include "version.hpp"
 
-#endif // NG_CORE_HPP
+#endif // NETGEN_CORE_NGCORE_HPP

libsrc/core/ngcore_api.hpp

@@ -0,0 +1,29 @@
+#ifndef NETGEN_CORE_NGCORE_API_HPP
+#define NETGEN_CORE_NGCORE_API_HPP
+
+#ifdef WIN32
+        #define NGCORE_API_EXPORT __declspec(dllexport)
+        #define NGCORE_API_IMPORT __declspec(dllimport)
+#else
+        #define NGCORE_API_EXPORT
+        #define NGCORE_API_IMPORT
+#endif
+
+#ifdef NGCORE_EXPORTS
+        #define NGCORE_API NGCORE_API_EXPORT
+#else
+        #define NGCORE_API NGCORE_API_IMPORT
+#endif
+
+namespace ngcore
+{
+#if defined(__GNUC__)
+  inline bool likely (bool x) { return bool(__builtin_expect(long(x), 1L)); }
+  inline bool unlikely (bool x) { return bool(__builtin_expect(long(x), 0L)); }
+#else
+  inline bool likely (bool x) { return x; }
+  inline bool unlikely (bool x) { return x; }
+#endif
+} // namespace ngcore
+
+#endif // NETGEN_CORE_NGCORE_API_HPP

libsrc/core/type_traits.hpp

@@ -1,11 +1,13 @@
 #ifndef NGS_TYPE_TRAITS_HPP
 #define NGS_TYPE_TRAITS_HPP
 
+#include <type_traits>
+
 namespace ngcore
 {
   template<bool... b> struct _BoolArray{};
   template<bool ... vals>
   constexpr bool all_of_tmpl = std::is_same<_BoolArray<vals...>, _BoolArray<(vals || true)...>>::value;
-}
+} // namespace ngcore
 
 #endif // NGS_TYPE_TRAITS_HPP

libsrc/core/version.cpp

@@ -0,0 +1,11 @@
+
+#include "archive.hpp"
+#include "version.hpp"
+
+namespace ngcore
+{
+  void VersionInfo :: DoArchive(Archive& ar)
+  {
+    ar & mayor_ & minor_ & release & patch & git_hash;
+  }
+} // namespace ngcore

libsrc/core/version.hpp

@@ -1,8 +1,13 @@
-#ifndef NGS_VERSION_HPP
+#ifndef NETGEN_CORE_VERSION_HPP
-#define NGS_VERSION_HPP
+#define NETGEN_CORE_VERSION_HPP
+
+#include <string>
+#include <tuple>
+#include "ngcore_api.hpp"
 
 namespace ngcore
 {
+  class Archive;
   class VersionInfo
   {
   private:
@@ -78,10 +83,8 @@ namespace ngcore
     bool operator <=(const VersionInfo& other) const { return !((*this) > other); }
     bool operator >=(const VersionInfo& other) const { return !((*this) < other); }
 
-    void DoArchive(Archive& ar)
+    void DoArchive(Archive& ar);
-    {
-      ar & mayor_ & minor_ & release & patch & git_hash;
-    }
   };
-}
+} // namespace ngcore
-#endif // NGS_VERSION_HPP
+
+#endif // NETGEN_CORE_VERSION_HPP

tests/catch/CMakeLists.txt

@@ -28,4 +28,10 @@ endmacro()
 
 add_unit_test(archive archive.cpp)
 add_unit_test(version version.cpp)
+
+if(ENABLE_CPP_CORE_GUIDELINES_CHECK)
+  set_target_properties(test_archive PROPERTIES CXX_CLANG_TIDY "${DO_CLANG_TIDY}")
+  set_target_properties(test_version PROPERTIES CXX_CLANG_TIDY "${DO_CLANG_TIDY}")
+endif(ENABLE_CPP_CORE_GUIDELINES_CHECK)
+
 endif(ENABLE_UNIT_TESTS)