netgen-mesher 6.2.2506.post35.dev0__cp314-cp314-win_amd64.whl

netgen/include/core/exception.hpp

@@ -0,0 +1,145 @@
+#ifndef NETGEN_CORE_EXCEPTION_HPP
+#define NETGEN_CORE_EXCEPTION_HPP
+
+#include <cstddef>
+#include <sstream>         // for stringstream
+#include <stdexcept>       // for exception
+#include <string>          // for string
+
+#include "ngcore_api.hpp"  // for NGCORE_API
+#include "utils.hpp"       // for ToString
+
+
+namespace ngcore
+{
+  NGCORE_API std::string GetBackTrace();
+
+  // Exception for code that shouldn't be executed
+  class NGCORE_API UnreachableCodeException : public std::exception
+  {
+    const char* what() const noexcept override
+    {
+      return "Shouldn't get here, something went wrong!";
+    }
+  };
+
+  // Default exception class
+  class NGCORE_API Exception : public std::exception
+  {
+    /// a verbal description of the exception
+    std::string m_what;
+  public:
+    Exception() = default;
+    Exception(const Exception&) = default;
+    Exception(Exception&&) = default;
+    Exception(const std::string& s); //  : m_what(s) {}
+    Exception(const char* s); //  : m_what(s) {}
+    Exception(std::string_view s1, std::string_view s2);
+    Exception(std::string_view s1, std::string_view s2, std::string_view s3);
+    ~Exception() override = default;
+
+    [[noreturn]] static void Throw (std::string_view s1);
+    [[noreturn]] static void Throw (std::string_view s1, std::string_view s2);
+    [[noreturn]] static void Throw (std::string_view s1, std::string_view s2, std::string_view s3);
+    
+    Exception& operator =(const Exception&) = default;
+    Exception& operator =(Exception&&) noexcept = default;
+
+    /// append string to description
+    Exception & Append (const std::string & s) { m_what += s; return *this; }
+  /// append string to description
+    Exception & Append (const char * s) { m_what += s; return *this; }
+
+    /// verbal description of exception
+    const std::string & What() const { return m_what; }
+
+    /// implement virtual function of std::exception
+    const char* what() const noexcept override { return m_what.c_str(); }
+  };
+  
+  [[noreturn]] NGCORE_API void ThrowException(const std::string & s);
+  [[noreturn]] NGCORE_API void ThrowException(const char * s);
+  
+  // Out of Range exception
+  class NGCORE_API RangeException : public Exception
+  {
+  public:
+    /// where it occurs, index, minimal and maximal indices
+    RangeException (// const std::string & where,
+                    const char * where,
+                    ptrdiff_t ind, ptrdiff_t imin, ptrdiff_t imax);
+    /*
+    : Exception("")
+      {
+        std::stringstream str;
+        str << where << ": index " << ind << " out of range [" << imin << "," << imax << ")\n";
+        Append (str.str());
+        Append (GetBackTrace());
+      }
+    */
+    template<typename T>
+    RangeException(const std::string& where, const T& value)
+    {
+      std::stringstream str;
+      str << where << " called with wrong value " << value << "\n";
+      Append(str.str());
+    }
+  };
+
+  [[noreturn]] NGCORE_API void ThrowRangeException(const char * s, ptrdiff_t ind, ptrdiff_t imin, ptrdiff_t imax);
+  [[noreturn]] NGCORE_API void ThrowNotTheSameException(const char * s, ptrdiff_t a, ptrdiff_t b);
+  
+  
+  // Exception used if no simd implementation is available to fall back to standard evaluation
+  class NGCORE_API ExceptionNOSIMD : public Exception
+  { public: using Exception::Exception; };
+
+  template <typename T>
+  struct IsSafe {
+    constexpr operator bool() const { return false; } };
+
+  namespace detail {
+    template <typename T, typename Tmin, typename Tmax>
+    inline static constexpr void CheckRange(const char * s, const T& n, Tmin first, Tmax next)
+    {
+      if constexpr (!IsSafe<decltype(n)>())
+        if (n<first || n>=next)
+          ThrowRangeException(s, ptrdiff_t(n), ptrdiff_t(first), ptrdiff_t(next));
+    }
+
+    template <typename Ta, typename Tb>
+    inline static constexpr void CheckSame(const char * s, const Ta& a, const Tb& b)
+    {
+     if constexpr (!IsSafe<decltype(a)>() || !IsSafe<decltype(b)>())
+      if(a != b)
+      {
+        if constexpr(std::is_integral_v<decltype(a)> && std::is_same_v<decltype(a),decltype(b)>)
+          ThrowNotTheSameException(s, long(a), long(b)); \
+        else
+          throw Exception(std::string(s) + "\t: not the same, a="+ToString(a) + ", b="+ngcore::ToString(b) + GetBackTrace());
+      }
+    }
+  } // namespace detail
+} // namespace ngcore
+
+#define NETGEN_CORE_NGEXEPTION_STR_HELPER(x) #x
+#define NETGEN_CORE_NGEXEPTION_STR(x) NETGEN_CORE_NGEXEPTION_STR_HELPER(x)
+
+// Convenience macro to append file name and line of exception origin to the string
+#define NG_EXCEPTION(s) ngcore::Exception(__FILE__ ":" NETGEN_CORE_NGEXEPTION_STR(__LINE__) "\t"+std::string(s))
+
+#if defined(NETGEN_ENABLE_CHECK_RANGE) && !defined(__CUDA_ARCH__)
+#define NETGEN_CHECK_RANGE(value, min, max_plus_one) ngcore::detail::CheckRange(__FILE__ ":" NETGEN_CORE_NGEXEPTION_STR(__LINE__) "\t", value, min, max_plus_one);
+#define NETGEN_CHECK_SAME(a,b) ngcore::detail::CheckSame(__FILE__ ":" NETGEN_CORE_NGEXEPTION_STR(__LINE__) "\t", a, b);
+
+#define NETGEN_NOEXCEPT 
+#else // defined(NETGEN_ENABLE_CHECK_RANGE) && !defined(__CUDA_ARCH__)
+#define NETGEN_CHECK_RANGE(value, min, max)
+#define NETGEN_CHECK_SAME(a,b)
+// #define NETGEN_CHECK_SHAPE(a,b)
+#define NETGEN_NOEXCEPT noexcept
+#endif // defined(NETGEN_ENABLE_CHECK_RANGE) && !defined(__CUDA_ARCH__)
+
+
+  
+#endif // NETGEN_CORE_EXCEPTION_HPP

netgen/include/core/flags.hpp

@@ -0,0 +1,199 @@
+#ifndef NETGEN_CORE_FLAGS_HPP
+#define NETGEN_CORE_FLAGS_HPP
+
+
+/**************************************************************************/
+/* File:   flags.hpp                                                      */
+/* Author: Joachim Schoeberl                                              */
+/* Date:   10. Oct. 96                                                    */
+/**************************************************************************/
+
+#include <iostream>
+#include <memory>
+#include <string>
+#include <any>
+
+#include "array.hpp"
+#include "symboltable.hpp"
+#include "xbool.hpp"
+
+namespace ngcore
+{
+
+  /** 
+      A storage for command-line flags.
+      The flag structure maintains string flags, numerical flags,
+      define flags, string list flags, num list flags.
+  */
+  class NGCORE_API Flags 
+  {
+    /// string flags
+    SymbolTable<std::string> strflags;
+    /// numerical flags
+    SymbolTable<double> numflags;
+    /// define flags
+    SymbolTable<bool> defflags;
+    /// string list flags
+    SymbolTable<std::shared_ptr<Array<std::string>>> strlistflags;
+    /// numerical list flags
+    SymbolTable<std::shared_ptr<Array<double>>> numlistflags;
+    /// flags list flags
+    SymbolTable<Flags> flaglistflags;
+    /// any object can be stored as a flag
+    SymbolTable<std::any> anyflags;
+  public:
+    /// no flags
+    Flags ();
+    /// copy flags 
+    Flags (const Flags & flags);
+    /// steal flags
+    Flags (Flags && flags) = default;
+    ///
+    Flags (std::initializer_list<std::string> list);
+    /// 
+    Flags (std::string f1, std::string f2 = "", std::string f3 = "", std::string f4 = "", std::string f5 = "");
+    /// delete mem
+    ~Flags ();
+
+    Flags & operator= (const Flags & f2) = default;
+    Flags & operator= (Flags && f2) = default;
+
+    void DoArchive(class Archive& ar);
+
+    void Update(const Flags& other);
+  
+    /// Deletes all flags
+    void DeleteFlags ();
+
+    /// Sets string flag, overwrite if exists
+    Flags & SetFlag (const char * name, const std::string & val);
+    /// Sets string flag, overwrite if exists
+    Flags & SetFlag (const char * name, const char * str)
+    { return SetFlag (name, std::string(str)); }
+    /// Sets numerical flag, overwrite if exists
+    Flags & SetFlag (const char * name, double val) &;
+    /// Sets numerical flag, overwrite if exists    
+    Flags & SetFlag (const char * name, int val)
+    { return SetFlag (name, double(val)); }
+    /// Sets boolean flag
+    Flags & SetFlag (const char * name, bool b = true) &;
+    /// Sets numerical flag, overwrite if exists
+    Flags & SetFlag (const char * name, Flags & val) &;
+
+    /// Sets string flag, overwrite if exists
+    Flags & SetFlag (const std::string & name, const std::string & val);
+    Flags & SetFlag (const std::string & name, const char * str)
+    { return SetFlag (name, std::string(str)); }
+    /// Sets numerical flag, overwrite if exists
+    Flags &  SetFlag (const std::string & name, double val);
+    /// Sets numerical flag, overwrite if exists    
+    Flags &  SetFlag (const std::string & name, int val)
+    { return SetFlag (name, double(val)); }
+    /// Sets boolean flag
+    Flags &  SetFlag (const std::string & name, bool b = true);
+    /// Sets numerical flag, overwrite if exists
+    Flags &  SetFlag (const std::string & name, Flags & val);
+    /// Sets string array flag
+    Flags &  SetFlag (const std::string & name, const Array<std::string> & val);
+    /// Sets double array flag
+    Flags &  SetFlag (const std::string & name, const Array<double> & val);
+    /// Sets any flag
+    Flags &  SetFlag(const std::string& name, const std::any& val);
+
+
+    Flags SetFlag (const char * name, bool b = true) &&;
+    Flags SetFlag (const char * name, double val) &&;
+
+
+
+    /// Save flags to file
+    void SaveFlags (const char * filename) const;
+    void SaveFlags (ostream & str) const;
+    /// write flags to stream
+    void PrintFlags (ostream & ost) const;
+    /// Load flags from file
+    void LoadFlags (const char * filename, SymbolTable<Flags> * sf = nullptr);
+    void LoadFlags (std::istream & str, SymbolTable<Flags> * sf = nullptr);
+    /**
+       Set command line flag.
+       Flag must be in form: -name=hello -val=0.5 -defflag 
+       -names=[Joe,Jim] -values=[1,3,4] -solverflags=*abc
+    */
+    void SetCommandLineFlag (const char * st, SymbolTable<Flags> * sf = nullptr);
+    /// Returns string flag, default value if not exists
+    std::string GetStringFlag (const std::string & name, const char * def) const;
+    /// Returns std::string flag, default value if not exists
+    std::string GetStringFlag (const std::string & name, std::string def = "") const;
+    /// Returns numerical flag, default value if not exists
+    double GetNumFlag (std::string_view name, double def) const;
+    /// Returns address of numerical flag, null if not exists
+    const double * GetNumFlagPtr (std::string_view name) const;
+    /// Returns address of numerical flag, null if not exists
+    double * GetNumFlagPtr (const std::string & name);
+    /// Returns boolean flag
+    // int GetDefineFlag (const char * name) const;
+    bool GetDefineFlag (std::string_view name) const  noexcept;
+    xbool GetDefineFlagX (std::string_view name) const  noexcept;
+    /// Returns string list flag, empty array if not exist
+    const Array<std::string> & GetStringListFlag (const std::string & name) const;
+    /// Returns num list flag, empty array if not exist
+    const Array<double> & GetNumListFlag (const std::string & name) const;
+    /// Returns flag list flag, empty flag if not exist
+    const Flags & GetFlagsFlag (const std::string & name) const;
+    const std::any& GetAnyFlag (const std::string& name) const;
+
+
+    /// Test, if string flag is defined
+    bool StringFlagDefined (std::string_view name) const noexcept;
+    /// Test, if num flag is defined
+    bool NumFlagDefined (std::string_view name) const noexcept;
+    /// Test, if num flag is defined
+    bool FlagsFlagDefined (std::string_view name) const noexcept;
+    /// Test, if string list flag is defined
+    bool StringListFlagDefined (std::string_view name) const noexcept;
+    /// Test, if num list flag is defined
+    bool NumListFlagDefined (std::string_view name) const noexcept;
+    bool AnyFlagDefined (std::string_view name) const noexcept;
+
+    /// number of string flags
+    int GetNStringFlags () const { return strflags.Size(); }
+    /// number of num flags
+    int GetNNumFlags () const { return numflags.Size(); }
+    /// number of num flags
+    int GetNFlagsFlags () const { return flaglistflags.Size(); }
+    /// number of define flags
+    int GetNDefineFlags () const { return defflags.Size(); }
+    /// number of string-list flags
+    int GetNStringListFlags () const { return strlistflags.Size(); }
+    /// number of num-list flags
+    int GetNNumListFlags () const { return numlistflags.Size(); }
+    int GetNAnyFlags() const { return anyflags.Size(); }
+
+    ///
+    const std::string & GetStringFlag (int i, std::string & name) const
+    { name = strflags.GetName(i); return strflags[i]; }
+    double GetNumFlag (int i, std::string & name) const
+    { name = numflags.GetName(i); return numflags[i]; }
+    bool GetDefineFlag (int i, std::string & name) const
+    { name = defflags.GetName(i); return defflags[i]; }
+    const std::shared_ptr<Array<double>> GetNumListFlag (int i, std::string & name) const
+    { name = numlistflags.GetName(i).c_str(); return numlistflags[i]; }
+    const std::shared_ptr<Array<std::string>> GetStringListFlag (int i, std::string & name) const
+    { name = strlistflags.GetName(i); return strlistflags[i]; }
+    const Flags & GetFlagsFlag (int i, std::string & name) const
+    { name = flaglistflags.GetName(i); return flaglistflags[i]; }
+    const std::any& GetAnyFlag(int i, std::string& name) const
+    { name = anyflags.GetName(i); return anyflags[i]; }
+  };
+
+  /// Print flags
+  inline std::ostream & operator<< (std::ostream & s, const Flags & flags)
+  {
+    flags.PrintFlags (s);
+    return s;
+  }
+} // namespace ngcore
+
+  
+#endif // NETGEN_CORE_FLAGS_HPP
+