passagemath-gap-pkg-semigroups 10.6.30__cp310-cp310-macosx_13_0_arm64.whl

gap/pkg/semigroups/gapbind14/include/gapbind14/to_cpp.hpp

@@ -0,0 +1,162 @@
+//
+// gapbind14
+// Copyright (C) 2020-2022 James D. Mitchell
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+//
+
+#ifndef INCLUDE_GAPBIND14_TO_CPP_HPP_
+#define INCLUDE_GAPBIND14_TO_CPP_HPP_
+
+#include <cstddef>      // for size_t
+#include <string>       // for string
+#include <type_traits>  // for enable_if_t, is_const, is_integral, is_same
+#include <vector>       // for vector
+
+#include "gap_include.hpp"
+
+namespace gapbind14 {
+
+  template <typename T>
+  struct IsGapBind14Type;
+
+  using gap_tnum_type = UInt;
+
+  // For Obj -> T
+  template <typename T, typename = void>
+  struct to_cpp;
+
+  template <typename T>
+  struct to_cpp<
+      T &,
+      std::enable_if_t<!IsGapBind14Type<T>::value && !std::is_const<T>::value>>
+      : to_cpp<T> {};
+
+  template <typename T>
+  struct to_cpp<T const &, std::enable_if_t<!IsGapBind14Type<T>::value>>
+      : to_cpp<T> {};
+
+  template <typename T>
+  struct to_cpp<T &&, std::enable_if_t<!IsGapBind14Type<T>::value>>
+      : to_cpp<T> {};
+
+  ////////////////////////////////////////////////////////////////////////
+  // void
+  ////////////////////////////////////////////////////////////////////////
+
+  template <>
+  struct to_cpp<void> {
+    using cpp_type                          = void;
+    static gap_tnum_type constexpr gap_type = 0;
+
+    void operator()() const noexcept {}
+  };
+
+  ////////////////////////////////////////////////////////////////////////
+  // Obj
+  ////////////////////////////////////////////////////////////////////////
+
+  template <>
+  struct to_cpp<Obj> {
+    using cpp_type = Obj;
+
+    Obj operator()(Obj o) const noexcept {
+      return o;
+    }
+  };
+
+  ////////////////////////////////////////////////////////////////////////
+  // Strings
+  ////////////////////////////////////////////////////////////////////////
+
+  template <>
+  struct to_cpp<std::string> {
+    using cpp_type                          = std::string;
+    static gap_tnum_type constexpr gap_type = T_STRING;
+
+    std::string operator()(Obj o) const {
+      if (!IS_STRING_REP(o)) {
+        throw std::runtime_error(std::string("expected string, found ")
+                                 + TNAM_OBJ(o));
+      }
+      return std::string(CSTR_STRING(o), GET_LEN_STRING(o));
+    }
+  };
+
+  ////////////////////////////////////////////////////////////////////////
+  // Integers
+  ////////////////////////////////////////////////////////////////////////
+
+  template <typename T>
+  struct to_cpp<T,
+                std::enable_if_t<std::is_integral<T>::value
+                                 && !std::is_same<T, bool>::value>> {
+    using cpp_type                          = T;
+    static gap_tnum_type constexpr gap_type = T_INT;
+
+    Int operator()(Obj o) const {
+      if (TNUM_OBJ(o) != T_INT) {
+        throw std::runtime_error(std::string("expected int, found ")
+                                 + TNAM_OBJ(o));
+      }
+      return INT_INTOBJ(o);
+    }
+  };
+
+  ////////////////////////////////////////////////////////////////////////
+  // Bools
+  ////////////////////////////////////////////////////////////////////////
+
+  template <>
+  struct to_cpp<bool> {
+    using cpp_type                          = bool;
+    static gap_tnum_type constexpr gap_type = T_BOOL;
+
+    bool operator()(Obj o) const {
+      if (TNUM_OBJ(o) != T_BOOL) {
+        throw std::runtime_error(std::string("expected bool, found ")
+                                 + TNAM_OBJ(o));
+      }
+      return o == True ? true : false;
+    }
+  };
+
+  ////////////////////////////////////////////////////////////////////////
+  // Vectors
+  ////////////////////////////////////////////////////////////////////////
+
+  template <typename T>
+  struct to_cpp<std::vector<T>> {
+    using cpp_type                          = std::vector<T>;
+    static gap_tnum_type constexpr gap_type = T_PLIST_HOM;
+
+    std::vector<T> operator()(Obj o) const {
+      if (!IS_LIST(o)) {
+        throw std::runtime_error(std::string("expected list, found ")
+                                 + TNAM_OBJ(o));
+      }
+
+      size_t const N   = LEN_LIST(o);
+      using value_type = typename std::vector<T>::value_type;
+      std::vector<T> result;
+      result.reserve(N);
+      for (size_t i = 0; i < N; ++i) {
+        result.push_back(to_cpp<value_type>()(ELM_LIST(o, i + 1)));
+      }
+      return result;
+    }
+  };
+
+}  // namespace gapbind14
+#endif  // INCLUDE_GAPBIND14_TO_CPP_HPP_

gap/pkg/semigroups/gapbind14/include/gapbind14/to_gap.hpp

@@ -0,0 +1,158 @@
+//
+// gapbind14
+// Copyright (C) 2020-2022 James D. Mitchell
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+//
+
+#ifndef INCLUDE_GAPBIND14_TO_GAP_HPP_
+#define INCLUDE_GAPBIND14_TO_GAP_HPP_
+
+#include <cstddef>      // for size_t
+#include <string>       // for string
+#include <type_traits>  // for enable_if_t, is_integral, is_same
+#include <utility>      // for pair
+#include <vector>       // for vector
+
+#include "gap_include.hpp"  // for Obj, UInt
+
+namespace gapbind14 {
+
+  template <typename T>
+  struct IsGapBind14Type;
+
+  using gap_tnum_type = UInt;
+
+  template <typename T, typename = void>
+  struct to_gap;
+
+  template <typename T>
+  struct to_gap<
+      T&,
+      std::enable_if_t<!IsGapBind14Type<T>::value && !std::is_const<T>::value>>
+      : to_gap<T> {};
+
+  template <typename T>
+  struct to_gap<T const&, std::enable_if_t<!IsGapBind14Type<T>::value>>
+      : to_gap<T> {};
+
+  template <typename T>
+  struct to_gap<T&&, std::enable_if_t<!IsGapBind14Type<T>::value>> : to_gap<T> {
+  };
+
+  ////////////////////////////////////////////////////////////////////////
+  // Obj
+  ////////////////////////////////////////////////////////////////////////
+
+  template <>
+  struct to_gap<Obj> {
+    using cpp_type = Obj;
+    Obj operator()(Obj x) const noexcept {
+      return x;
+    }
+  };
+
+  ////////////////////////////////////////////////////////////////////////
+  // Strings
+  ////////////////////////////////////////////////////////////////////////
+
+  template <>
+  struct to_gap<std::string> {
+    using cpp_type                          = std::string;
+    static gap_tnum_type constexpr gap_type = T_STRING;
+
+    Obj operator()(std::string const& str) const {
+      return MakeStringWithLen(str.c_str(), str.length());
+    }
+  };
+
+  ////////////////////////////////////////////////////////////////////////
+  // Integers
+  ////////////////////////////////////////////////////////////////////////
+
+  template <typename T>
+  struct to_gap<T,
+                std::enable_if_t<std::is_integral<T>::value
+                                 && !std::is_same<T, bool>::value>> {
+    using cpp_type                          = T;
+    static gap_tnum_type constexpr gap_type = T_INT;
+
+    Obj operator()(T&& i) const {
+      return INTOBJ_INT(i);
+    }
+
+    Obj operator()(T const& i) const {
+      return INTOBJ_INT(i);
+    }
+  };
+
+  ////////////////////////////////////////////////////////////////////////
+  // Bools
+  ////////////////////////////////////////////////////////////////////////
+
+  template <>
+  struct to_gap<bool> {
+    using cpp_type                          = bool;
+    static gap_tnum_type constexpr gap_type = T_BOOL;
+
+    Obj operator()(bool&& val) const noexcept {
+      return (val ? True : False);
+    }
+
+    Obj operator()(bool const& val) const noexcept {
+      return (val ? True : False);
+    }
+  };
+
+  ////////////////////////////////////////////////////////////////////////
+  // Vectors
+  ////////////////////////////////////////////////////////////////////////
+
+  template <typename T>
+  struct to_gap<std::vector<T>> {
+    using cpp_type                          = std::vector<T>;
+    static gap_tnum_type constexpr gap_type = T_PLIST_HOM;
+
+    Obj operator()(std::vector<T> const& v) const {
+      Obj result = NEW_PLIST(T_PLIST_HOM, v.size());
+      SET_LEN_PLIST(result, v.size());
+      using value_type = typename std::vector<T>::value_type;
+      size_t index     = 1;
+      for (auto const& item : v) {
+        AssPlist(result, index++, to_gap<value_type>()(item));
+      }
+      return result;
+    }
+  };
+
+  ////////////////////////////////////////////////////////////////////////
+  // Pairs
+  ////////////////////////////////////////////////////////////////////////
+
+  template <typename S, typename T>
+  struct to_gap<std::pair<S, T>> {
+    using cpp_type                          = std::pair<S, T>;
+    static gap_tnum_type constexpr gap_type = T_PLIST;
+
+    Obj operator()(std::pair<S, T> const& p) const {
+      Obj result = NEW_PLIST(T_PLIST, 2);
+      SET_LEN_PLIST(result, 2);
+      AssPlist(result, 1, to_gap<S>()(p.first));
+      AssPlist(result, 2, to_gap<T>()(p.second));
+      return result;
+    }
+  };
+
+}  // namespace gapbind14
+#endif  // INCLUDE_GAPBIND14_TO_GAP_HPP_

gap/pkg/semigroups/gapbind14/src/.clang-format

@@ -0,0 +1,108 @@
+---
+# BasedOnStyle:  LLVM
+AccessModifierOffset: -1
+AlignAfterOpenBracket: Align
+AlignConsecutiveAssignments: true
+AlignConsecutiveDeclarations: true
+AlignEscapedNewlines: Left
+AlignOperands:   true
+AlignTrailingComments: true
+AllowAllParametersOfDeclarationOnNextLine: false
+AllowShortBlocksOnASingleLine: false
+AllowShortCaseLabelsOnASingleLine: false
+AllowShortFunctionsOnASingleLine: Empty
+AllowShortIfStatementsOnASingleLine: false
+AllowShortLoopsOnASingleLine: false
+AlwaysBreakAfterReturnType: None
+AlwaysBreakBeforeMultilineStrings: false
+AlwaysBreakTemplateDeclarations: false
+BinPackArguments: false
+BinPackParameters: false
+BraceWrapping:   
+  AfterClass:      false
+  AfterControlStatement: false
+  AfterEnum:       false
+  AfterFunction:   false
+  AfterNamespace:  false
+  AfterObjCDeclaration: false
+  AfterStruct:     false
+  AfterUnion:      false
+  BeforeCatch:     false
+  BeforeElse:      false
+  IndentBraces:    false
+BreakAfterJavaFieldAnnotations: false
+BreakBeforeBinaryOperators: All
+BreakBeforeBraces: Attach
+BreakBeforeInheritanceComma: false
+BreakBeforeTernaryOperators: true
+BreakConstructorInitializers: BeforeColon
+BreakStringLiterals: true
+ColumnLimit:     80
+CompactNamespaces: false
+CommentPragmas:  '^ IWYU pragma:'
+ConstructorInitializerAllOnOneLineOrOnePerLine: true
+ConstructorInitializerIndentWidth: 4
+ContinuationIndentWidth: 4
+Cpp11BracedListStyle: true
+DerivePointerAlignment: true
+DisableFormat:   false
+ExperimentalAutoDetectBinPacking: false
+FixNamespaceComments: true
+ForEachMacros:  ['RANGES_FOR', 'FOREACH']
+IncludeBlocks: Preserve
+IncludeCategories: 
+  - Regex:           '^"(llvm|llvm-c|clang|clang-c)/'
+    Priority:        2
+  - Regex:           '^(<|"(gtest|isl|json)/)'
+    Priority:        3
+  - Regex:           '.*'
+    Priority:        1
+IncludeIsMainRegex: '$'
+IndentCaseLabels: true
+IndentPPDirectives: None
+IndentWidth:     2
+IndentWrappedFunctionNames: false
+JavaScriptQuotes: Leave
+JavaScriptWrapImports: true
+KeepEmptyLinesAtTheStartOfBlocks: false
+Language:        Cpp
+MacroBlockBegin: ''
+MacroBlockEnd:   ''
+MaxEmptyLinesToKeep: 1
+NamespaceIndentation: All
+ObjCBlockIndentWidth: 2
+ObjCSpaceAfterProperty: false
+ObjCSpaceBeforeProtocolList: true
+PenaltyBreakAssignment: 2
+PenaltyBreakBeforeFirstCallParameter: 19
+PenaltyBreakComment: 300
+PenaltyBreakFirstLessLess: 200
+PenaltyBreakString: 1000
+PenaltyExcessCharacter: 1000000
+PenaltyReturnTypeOnItsOwnLine: 600
+PointerAlignment: Left
+#RawStringFormats: 
+#  - Delimiter:       pb
+#    Language:        TextProto
+#    BasedOnStyle:    google
+ReflowComments:  true
+SortIncludes:    true
+SpaceAfterCStyleCast: true
+SpaceAfterTemplateKeyword: true
+SpaceBeforeAssignmentOperators: true
+#SpaceBeforeCtorInitializerColon: true
+#SpaceBeforeInheritanceColon: true
+SpaceBeforeParens: ControlStatements
+#SpaceBeforeRangeBasedForLoopColon: true
+SpaceInEmptyParentheses: false
+SpacesBeforeTrailingComments: 2
+SpacesInAngles:  false
+SpacesInCStyleCastParentheses: false
+SpacesInContainerLiterals: true
+SpacesInParentheses: false
+SpacesInSquareBrackets: false
+Standard:        Cpp11
+TabWidth:        2
+UseTab:          Never
+...
+