feat(Exception): new exception at library scope by BotellaA · Pull Request #1264 · Geode-solutions/OpenGeode

BotellaA · 2026-04-23T14:42:59Z

BREAKING CHANGE: EXCEPTION and ASSERT macros are removed

github-actions · 2026-04-23T14:57:06Z

Cpp-Linter Report ⚠️

Some files did not pass the configured checks!

clang-tidy (v20.1.8) reports: 5300 concern(s)

include/geode/basic/assert.hpp:116:9: warning: [cppcoreguidelines-pro-type-member-init]

constructor does not initialize these fields: stack_
```
  116 |         explicit OpenGeodeException( std::string project,
      |         ^
```

include/geode/basic/assert.hpp:116:18: warning: [readability-function-size]

function 'OpenGeodeException' exceeds recommended size/complexity thresholds

  116 |         explicit OpenGeodeException( std::string project,
      |                  ^
/__w/OpenGeode/OpenGeode/include/geode/basic/assert.hpp:116:18: note: 5 parameters (threshold 4)

include/geode/basic/assert.hpp:129:13: warning: [cppcoreguidelines-prefer-member-initializer]

'stack_size_' should be initialized in a member initializer of the constructor

  125 |               data_{ std::move( data ) }
      |                                         
  126 |         {
  127 |             stack_.fill( nullptr );
  128 | #ifndef NDEBUG
  129 |             stack_size_ = absl::GetStackTrace(
      |             ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  130 |                 stack_.data(), MAX_STACK_DEPTH, NB_SKIPPED_STACKS );
      |                 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

include/geode/basic/attribute.hpp:51:11: warning: [cppcoreguidelines-special-member-functions]

class 'AttributeBase' defines a default destructor, a copy constructor and a copy assignment operator but does not define a move constructor or a move assignment operator
```
   51 |     class AttributeBase
      |           ^
```
include/geode/basic/attribute.hpp:84:27: warning: [hicpp-move-const-arg]

std::move of the variable 'new_properties' of the trivially-copyable type 'AttributeProperties' has no effect; remove std::move()
```
   84 |             properties_ = std::move( new_properties );
      |                           ^~~~~~~~~~                ~
```
include/geode/basic/attribute.hpp:156:9: warning: [google-explicit-constructor]

single-argument constructors must be marked explicit to avoid unintentional implicit conversions
```
  156 |         AttributeBase( AttributeProperties properties )
      |         ^
      |         explicit 
```
include/geode/basic/attribute.hpp:157:28: warning: [hicpp-move-const-arg]

std::move of the variable 'properties' of the trivially-copyable type 'AttributeProperties' has no effect; remove std::move()
```
  157 |             : properties_( std::move( properties ) )
      |                            ^~~~~~~~~~            ~
```
include/geode/basic/attribute.hpp:207:9: warning: [google-explicit-constructor]

single-argument constructors must be marked explicit to avoid unintentional implicit conversions
```
  207 |         ReadOnlyAttribute( AttributeProperties properties )
      |         ^
      |         explicit 
```
include/geode/basic/attribute_utils.hpp:140:9: warning: [cppcoreguidelines-macro-usage]

function-like macro 'IMPLICIT_ATTRIBUTE_LINEAR_INTERPOLATION' used; consider a 'constexpr' template function
```
  140 | #define IMPLICIT_ATTRIBUTE_LINEAR_INTERPOLATION( Type )                        \
      |         ^
```
include/geode/basic/attribute_utils.hpp:174:9: warning: [cppcoreguidelines-macro-usage]

function-like macro 'IMPLICIT_ARRAY_ATTRIBUTE_LINEAR_INTERPOLATION' used; consider a 'constexpr' template function
```
  174 | #define IMPLICIT_ARRAY_ATTRIBUTE_LINEAR_INTERPOLATION( Type )                  \
      |         ^
```
include/geode/basic/attribute_utils.hpp:253:9: warning: [cppcoreguidelines-macro-usage]

function-like macro 'IMPLICIT_GENERIC_ATTRIBUTE_CONVERSION' used; consider a 'constexpr' template function
```
  253 | #define IMPLICIT_GENERIC_ATTRIBUTE_CONVERSION( Type )                          \
      |         ^
```
include/geode/basic/attribute_utils.hpp:289:9: warning: [cppcoreguidelines-macro-usage]

function-like macro 'IMPLICIT_ARRAY_GENERIC_ATTRIBUTE_CONVERSION' used; consider a 'constexpr' template function
```
  289 | #define IMPLICIT_ARRAY_GENERIC_ATTRIBUTE_CONVERSION( Type )                    \
      |         ^
```
include/geode/basic/cached_value.hpp:38:11: warning: [cppcoreguidelines-special-member-functions]

class 'CachedValue' defines a copy constructor, a copy assignment operator, a move constructor and a move assignment operator but does not define a destructor
```
   38 |     class CachedValue
      |           ^
```

include/geode/basic/cached_value.hpp:43:22: warning: [modernize-type-traits]

use c++14 style type templates

   43 |             typename std::add_pointer< ReturnType( Args... ) >::type;
      |             ~~~~~~~~ ^                                        ~~~~~~
      |                                      _t

include/geode/basic/cached_value.hpp:48:13: warning: [cppcoreguidelines-prefer-member-initializer]

'value_' should be initialized in a member initializer of the constructor

   46 |         CachedValue( const CachedValue& other )
      |                                                
      |                                                 : value_(other.value_)
   47 |         {
   48 |             value_ = other.value_;
      |             ^~~~~~~~~~~~~~~~~~~~~~

include/geode/basic/cached_value.hpp:49:13: warning: [cppcoreguidelines-prefer-member-initializer]

'computed_' should be initialized in a member initializer of the constructor

   46 |         CachedValue( const CachedValue& other )
      |                                                
      |                                                , computed_(other.computed_.load())
   47 |         {
   48 |             value_ = other.value_;
   49 |             computed_ = other.computed_.load();
      |             ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

include/geode/basic/cached_value.hpp:53:13: warning: [cppcoreguidelines-prefer-member-initializer]

'value_' should be initialized in a member initializer of the constructor

   51 |         CachedValue( CachedValue&& other ) noexcept
      |                                                    
      |                                                     : value_(std::move( other.value_ ))
   52 |         {
   53 |             value_ = std::move( other.value_ );
      |             ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

include/geode/basic/cached_value.hpp:54:13: warning: [cppcoreguidelines-prefer-member-initializer]

'computed_' should be initialized in a member initializer of the constructor

   51 |         CachedValue( CachedValue&& other ) noexcept
      |                                                    
      |                                                    , computed_(other.computed_.load())
   52 |         {
   53 |             value_ = std::move( other.value_ );
   54 |             computed_ = other.computed_.load();
      |             ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

include/geode/basic/cached_value.hpp:57:22: warning: [cert-oop54-cpp]

operator=() does not handle self-assignment properly
```
   57 |         CachedValue& operator=( const CachedValue& other )
      |                      ^
```

include/geode/basic/cached_value.hpp:119:38: warning: [cppcoreguidelines-init-variables]

variable 'computed' is not initialized

  119 |                                 bool computed;
      |                                      ^       
      |                                               = false

include/geode/basic/cell_array.hpp:28:10: warning: [misc-header-include-cycle]

direct self-inclusion of header file 'cell_array.hpp'
```
   28 | #include <geode/basic/cell_array.hpp>
      |          ^
```
include/geode/basic/cell_array.hpp:82:9: warning: [google-explicit-constructor]

single-argument constructors must be marked explicit to avoid unintentional implicit conversions
```
   82 |         CellArray( std::array< index_t, dimension > cells_number );
      |         ^
      |         explicit 
```
include/geode/basic/common.hpp:48:9: warning: [cppcoreguidelines-macro-usage]

function-like macro 'OPENGEODE_DISABLE_COPY' used; consider a 'constexpr' template function
```
   48 | #define OPENGEODE_DISABLE_COPY( Class )                                        \
      |         ^
```
include/geode/basic/common.hpp:51:5: warning: [bugprone-macro-parentheses]

macro argument should be enclosed in parentheses
```
   51 |     Class &operator=( const Class & ) = delete
      |     ^
      |     (    )
```
include/geode/basic/common.hpp:53:9: warning: [cppcoreguidelines-macro-usage]

function-like macro 'OPENGEODE_DISABLE_MOVE' used; consider a 'constexpr' template function
```
   53 | #define OPENGEODE_DISABLE_MOVE( Class )                                        \
      |         ^
```

include/geode/basic/common.hpp:55:12: warning: [bugprone-macro-parentheses]

macro argument should be enclosed in parentheses

   55 |     Class( Class && ) = delete;                                                \
      |            ^
      |            (    )

include/geode/basic/common.hpp:56:5: warning: [bugprone-macro-parentheses]

macro argument should be enclosed in parentheses
```
   56 |     Class &operator=( Class && ) = delete
      |     ^
      |     (    )
```

include/geode/basic/common.hpp:56:23: warning: [bugprone-macro-parentheses]

macro argument should be enclosed in parentheses

   56 |     Class &operator=( Class && ) = delete
      |                       ^
      |                       (    )

include/geode/basic/common.hpp:58:9: warning: [cppcoreguidelines-macro-usage]

function-like macro 'OPENGEODE_DISABLE_COPY_AND_MOVE' used; consider a 'constexpr' template function
```
   58 | #define OPENGEODE_DISABLE_COPY_AND_MOVE( Class )                               \
      |         ^
```

include/geode/basic/common.hpp:72:45: warning: [bugprone-macro-parentheses]

macro argument should be enclosed in parentheses

   72 | #define ALIAS_1D( Class ) using Class##1D = Class< 1 >
      |                                             ^    
      |                                             (    )

include/geode/basic/common.hpp:74:45: warning: [bugprone-macro-parentheses]

macro argument should be enclosed in parentheses

   74 | #define ALIAS_2D( Class ) using Class##2D = Class< 2 >
      |                                             ^    
      |                                             (    )

include/geode/basic/common.hpp:76:45: warning: [bugprone-macro-parentheses]

macro argument should be enclosed in parentheses

   76 | #define ALIAS_3D( Class ) using Class##3D = Class< 3 >
      |                                             ^    
      |                                             (    )

include/geode/basic/common.hpp:78:9: warning: [cppcoreguidelines-macro-usage]

function-like macro 'ALIAS_2D_AND_3D' used; consider a 'constexpr' template function
```
   78 | #define ALIAS_2D_AND_3D( Class )                                               \
      |         ^
```
include/geode/basic/common.hpp:82:9: warning: [cppcoreguidelines-macro-usage]

function-like macro 'ALIAS_1D_AND_2D_AND_3D' used; consider a 'constexpr' template function
```
   82 | #define ALIAS_1D_AND_2D_AND_3D( Class )                                        \
      |         ^
```
include/geode/basic/common.hpp:87:9: warning: [cppcoreguidelines-macro-usage]

function-like macro 'FORWARD_DECLARATION_DIMENSION_CLASS' used; consider a 'constexpr' template function
```
   87 | #define FORWARD_DECLARATION_DIMENSION_CLASS( Class )                           \
      |         ^
```
include/geode/basic/common.hpp:91:9: warning: [cppcoreguidelines-macro-usage]

function-like macro 'FORWARD_DECLARATION_DIMENSION_STRUCT' used; consider a 'constexpr' template function
```
   91 | #define FORWARD_DECLARATION_DIMENSION_STRUCT( Struct )                         \
      |         ^
```
include/geode/basic/growable.hpp:51:39: warning: [cppcoreguidelines-pro-type-const-cast]

do not use const_cast to remove const qualifier
```
   51 |             serializers_.back()( ser, const_cast< T & >( obj ) );
      |                                       ^
```

include/geode/basic/growable.hpp:75:31: warning: [readability-identifier-naming]

invalid case style for constexpr variable 'SupportValueOverload'

   75 |         static constexpr bool SupportValueOverload = false;
      |                               ^~~~~~~~~~~~~~~~~~~~
      |                               SUPPORT_VALUE_OVERLOAD

include/geode/basic/growable.hpp:76:31: warning: [readability-identifier-naming]

invalid case style for constexpr variable 'SupportObjectOverload'

   76 |         static constexpr bool SupportObjectOverload = true;
      |                               ^~~~~~~~~~~~~~~~~~~~~
      |                               SUPPORT_OBJECT_OVERLOAD

include/geode/basic/growable.hpp:77:31: warning: [readability-identifier-naming]

invalid case style for constexpr variable 'SupportLambdaOverload'

   77 |         static constexpr bool SupportLambdaOverload = true;
      |                               ^~~~~~~~~~~~~~~~~~~~~
      |                               SUPPORT_LAMBDA_OVERLOAD

include/geode/basic/identifier.hpp:45:31: warning: [cppcoreguidelines-special-member-functions]

class 'Identifier' defines a destructor, a move constructor and a move assignment operator but does not define a copy constructor or a copy assignment operator
```
   45 |     class opengeode_basic_api Identifier
      |                               ^
```

include/geode/basic/internal/array_impl.hpp:39:38: error: [clang-diagnostic-error]

no template named 'CellArray'

   39 |         using CellIndices = typename CellArray< dimension >::CellIndices;
      |                                      ^

include/geode/basic/internal/array_impl.hpp:42:43: warning: [bugprone-easily-swappable-parameters]

2 adjacent parameters of 'cell_index' of similar type ('const int &') are easily swapped by mistake

   42 |         [[nodiscard]] index_t cell_index( const CellArray< dimension >& array,
      |                                           ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
   43 |             const CellIndices& index ) const
      |             ~~~~~~~~~~~~~~~~~~~~~~~~
/__w/OpenGeode/OpenGeode/include/geode/basic/internal/array_impl.hpp:42:73: note: the first parameter in the range is 'array'
   42 |         [[nodiscard]] index_t cell_index( const CellArray< dimension >& array,
      |                                                                         ^~~~~
/__w/OpenGeode/OpenGeode/include/geode/basic/internal/array_impl.hpp:43:32: note: the last parameter in the range is 'index'
   43 |             const CellIndices& index ) const
      |                                ^~~~~

include/geode/basic/internal/array_impl.hpp:42:49: error: [clang-diagnostic-error]

no template named 'CellArray'

   42 |         [[nodiscard]] index_t cell_index( const CellArray< dimension >& array,
      |                                                 ^

include/geode/basic/internal/array_impl.hpp:43:19: error: [clang-diagnostic-error]

unknown type name 'CellIndices'
```
   43 |             const CellIndices& index ) const
      |                   ^
```
include/geode/basic/internal/array_impl.hpp:54:23: error: [clang-diagnostic-error]

unknown type name 'CellIndices'
```
   54 |         [[nodiscard]] CellIndices cell_indices(
      |                       ^
```

include/geode/basic/internal/array_impl.hpp:55:19: error: [clang-diagnostic-error]

no template named 'CellArray'

   55 |             const CellArray< dimension >& array, index_t index ) const
      |                   ^

include/geode/basic/internal/array_impl.hpp:59:13: error: [clang-diagnostic-error]

use of undeclared identifier 'CellIndices'; did you mean 'cell_indices'?

   59 |             CellIndices cell_id;
      |             ^~~~~~~~~~~
      |             cell_indices
/__w/OpenGeode/OpenGeode/include/geode/basic/internal/array_impl.hpp:54:35: note: 'cell_indices' declared here
   54 |         [[nodiscard]] CellIndices cell_indices(
      |                                   ^

include/geode/basic/internal/array_impl.hpp:63:33: warning: [readability-identifier-length]

variable name 'd2' is too short, expected at least 3 characters
```
   63 |                 for( const auto d2 : LRange{ dimension - d - 1 } )
      |                                 ^
```
include/geode/basic/internal/array_impl.hpp:69:17: error: [clang-diagnostic-error]

use of undeclared identifier 'cell_id'
```
   69 |                 cell_id[dimension - d - 1] = value;
      |                 ^
```
include/geode/basic/internal/array_impl.hpp:72:20: error: [clang-diagnostic-error]

use of undeclared identifier 'cell_id'
```
   72 |             return cell_id;
      |                    ^
```

include/geode/basic/library.hpp:135:5: warning: [concurrency-mt-unsafe]

function is not thread safe

  135 |     OPENGEODE_LIBRARY( opengeode_basic_api, OpenGeode, Basic );
      |     ^
/__w/OpenGeode/OpenGeode/include/geode/basic/library.hpp:111:17: note: expanded from macro 'OPENGEODE_LIBRARY'
  111 |                 exit( 1 );                                                     \
      |                 ^

include/geode/basic/logger.hpp:41:31: warning: [cppcoreguidelines-special-member-functions]

class 'Logger' defines a destructor but does not define a copy constructor, a copy assignment operator, a move constructor or a move assignment operator
```
   41 |     class opengeode_basic_api Logger
      |                               ^
```

include/geode/basic/named_type.hpp:71:18: warning: [readability-identifier-naming]

invalid case style for global function 'AbslHashValue'

   71 |         friend H AbslHashValue( H h, const NamedType& value )
      |                  ^~~~~~~~~~~~~
      |                  absl_hash_value

include/geode/basic/named_type.hpp:71:35: warning: [readability-identifier-length]

parameter name 'h' is too short, expected at least 3 characters
```
   71 |         friend H AbslHashValue( H h, const NamedType& value )
      |                                   ^
```
include/geode/basic/passkey.hpp:63:9: warning: [cppcoreguidelines-macro-usage]

function-like macro 'PASSKEY' used; consider a 'constexpr' template function
```
   63 | #define PASSKEY( Friend, Key /*key*/ ) using Key = geode::PassKey< Friend >
      |         ^
```

include/geode/basic/passkey.hpp:63:46: warning: [bugprone-macro-parentheses]

macro argument should be enclosed in parentheses

   63 | #define PASSKEY( Friend, Key /*key*/ ) using Key = geode::PassKey< Friend >
      |                                              ^
      |                                              (  )

include/geode/basic/pimpl.hpp:55:9: warning: [cppcoreguidelines-macro-usage]

function-like macro 'IMPLEMENTATION_MEMBER' used; consider a 'constexpr' template function
```
   55 | #define IMPLEMENTATION_MEMBER( impl )                                          \
      |         ^
```
include/geode/basic/sparse_attribute.hpp:120:30: warning: [cppcoreguidelines-avoid-magic-numbers]

10 is a magic number; consider replacing it with a named constant
```
  120 |             values_.reserve( 10 );
      |                              ^
```

include/geode/basic/sparse_attribute.hpp:138:61: warning: [readability-identifier-length]

parameter name 'i' is too short, expected at least 3 characters

  138 |                             []( Archive& archive2, index_t& i, T& item ) {
      |                                                             ^

include/geode/basic/sparse_attribute.hpp:143:30: warning: [cppcoreguidelines-avoid-magic-numbers]

10 is a magic number; consider replacing it with a named constant
```
  143 |             values_.reserve( 10 );
      |                              ^
```
include/geode/basic/sparse_attribute.hpp:246:31: warning: [readability-identifier-length]

variable name 'in' is too short, expected at least 3 characters
```
  246 |             for( const auto& [in, outs] : old2new_mapping.in2out_map() )
      |                               ^
```
include/geode/basic/sparse_attribute.hpp:296:31: warning: [readability-identifier-length]

variable name 'in' is too short, expected at least 3 characters
```
  296 |             for( const auto& [in, outs] : old2new_mapping.in2out_map() )
      |                               ^
```

include/geode/basic/uuid.hpp:37:32: warning: [readability-identifier-naming]

invalid case style for struct 'uuid'

   37 |     struct opengeode_basic_api uuid
      |                                ^~~~
      |                                Uuid
   38 |     {
   39 |     public:
   40 |         uuid();
      |         ~~~~
      |         Uuid
   41 |         explicit uuid( std::string_view string );
      |                  ~~~~
      |                  Uuid
   42 |         uuid( const uuid & ) = default;
      |         ~~~~        ~~~~
      |         Uuid        Uuid
   43 |         uuid( uuid && ) = default;
      |         ~~~~  ~~~~
      |         Uuid  Uuid
   44 |         uuid &operator=( uuid &&other ) = default;
      |         ~~~~             ~~~~
      |         Uuid             Uuid
   45 |         uuid &operator=( const uuid &other ) = default;
      |         ~~~~                   ~~~~
      |         Uuid                   Uuid
   46 |         ~uuid() = default;
      |          ~~~~
      |          Uuid
   47 | 
   48 |         [[nodiscard]] bool operator==( const uuid &other ) const;
      |                                              ~~~~
      |                                              Uuid
   49 | 
   50 |         [[nodiscard]] bool operator!=( const uuid &other ) const;
      |                                              ~~~~
      |                                              Uuid
   51 | 
   52 |         [[nodiscard]] bool operator<( const uuid &other ) const;
      |                                             ~~~~
      |                                             Uuid

include/geode/basic/uuid.hpp:57:18: warning: [readability-identifier-naming]

invalid case style for global function 'AbslHashValue'

   57 |         friend H AbslHashValue( H h, const uuid &value )
      |                  ^~~~~~~~~~~~~
      |                  absl_hash_value

include/geode/basic/uuid.hpp:57:35: warning: [readability-identifier-length]

parameter name 'h' is too short, expected at least 3 characters
```
   57 |         friend H AbslHashValue( H h, const uuid &value )
      |                                   ^
```
include/geode/basic/uuid.hpp:62:35: warning: [cppcoreguidelines-avoid-magic-numbers]

16 is a magic number; consider replacing it with a named constant
```
   62 |         std::array< std::uint8_t, 16 > bytes_;
      |                                   ^
```

include/geode/basic/uuid.hpp:70:70: warning: [readability-identifier-length]

parameter name 'id' is too short, expected at least 3 characters

   70 |                                        { []( Archive &archive, uuid &id ) {
      |                                                                      ^

include/geode/basic/uuid.hpp:71:54: warning: [cppcoreguidelines-init-variables]

variable 'ab' is not initialized

   71 |                                             uint64_t ab;
      |                                                      ^ 
      |                                                         = 0

include/geode/basic/uuid.hpp:71:54: warning: [readability-identifier-length]

variable name 'ab' is too short, expected at least 3 characters

include/geode/basic/uuid.hpp:72:54: warning: [cppcoreguidelines-init-variables]

variable 'cd' is not initialized

   72 |                                             uint64_t cd;
      |                                                      ^ 
      |                                                         = 0

include/geode/basic/uuid.hpp:72:54: warning: [readability-identifier-length]

variable name 'cd' is too short, expected at least 3 characters

include/geode/basic/uuid.hpp:75:68: warning: [cppcoreguidelines-avoid-magic-numbers]

56 is a magic number; consider replacing it with a named constant

   75 |                                             id.bytes_[0] = ( ab >> 56 ) & 0xFF;
      |                                                                    ^

include/geode/basic/uuid.hpp:75:68: warning: [hicpp-signed-bitwise]

use of a signed integer operand with a binary bitwise operator

   75 |                                             id.bytes_[0] = ( ab >> 56 ) & 0xFF;
      |                                                                 ~~ ^~

include/geode/basic/uuid.hpp:75:75: warning: [cppcoreguidelines-avoid-magic-numbers]

0xFF is a magic number; consider replacing it with a named constant

   75 |                                             id.bytes_[0] = ( ab >> 56 ) & 0xFF;
      |                                                                           ^

include/geode/basic/uuid.hpp:75:75: warning: [hicpp-signed-bitwise]

use of a signed integer operand with a binary bitwise operator

   75 |                                             id.bytes_[0] = ( ab >> 56 ) & 0xFF;
      |                                                                         ~ ^~~~

include/geode/basic/uuid.hpp:76:68: warning: [cppcoreguidelines-avoid-magic-numbers]

48 is a magic number; consider replacing it with a named constant

   76 |                                             id.bytes_[1] = ( ab >> 48 ) & 0xFF;
      |                                                                    ^

include/geode/basic/uuid.hpp:76:68: warning: [hicpp-signed-bitwise]

use of a signed integer operand with a binary bitwise operator

   76 |                                             id.bytes_[1] = ( ab >> 48 ) & 0xFF;
      |                                                                 ~~ ^~

include/geode/basic/uuid.hpp:76:75: warning: [cppcoreguidelines-avoid-magic-numbers]

0xFF is a magic number; consider replacing it with a named constant

   76 |                                             id.bytes_[1] = ( ab >> 48 ) & 0xFF;
      |                                                                           ^

include/geode/basic/uuid.hpp:76:75: warning: [hicpp-signed-bitwise]

use of a signed integer operand with a binary bitwise operator

   76 |                                             id.bytes_[1] = ( ab >> 48 ) & 0xFF;
      |                                                                         ~ ^~~~

include/geode/basic/uuid.hpp:77:68: warning: [cppcoreguidelines-avoid-magic-numbers]

40 is a magic number; consider replacing it with a named constant

   77 |                                             id.bytes_[2] = ( ab >> 40 ) & 0xFF;
      |                                                                    ^

include/geode/basic/uuid.hpp:77:68: warning: [hicpp-signed-bitwise]

use of a signed integer operand with a binary bitwise operator

   77 |                                             id.bytes_[2] = ( ab >> 40 ) & 0xFF;
      |                                                                 ~~ ^~

include/geode/basic/uuid.hpp:77:75: warning: [cppcoreguidelines-avoid-magic-numbers]

0xFF is a magic number; consider replacing it with a named constant

   77 |                                             id.bytes_[2] = ( ab >> 40 ) & 0xFF;
      |                                                                           ^

include/geode/basic/uuid.hpp:77:75: warning: [hicpp-signed-bitwise]

use of a signed integer operand with a binary bitwise operator

   77 |                                             id.bytes_[2] = ( ab >> 40 ) & 0xFF;
      |                                                                         ~ ^~~~

include/geode/basic/uuid.hpp:78:68: warning: [cppcoreguidelines-avoid-magic-numbers]

32 is a magic number; consider replacing it with a named constant

   78 |                                             id.bytes_[3] = ( ab >> 32 ) & 0xFF;
      |                                                                    ^

include/geode/basic/uuid.hpp:78:68: warning: [hicpp-signed-bitwise]

use of a signed integer operand with a binary bitwise operator

   78 |                                             id.bytes_[3] = ( ab >> 32 ) & 0xFF;
      |                                                                 ~~ ^~

include/geode/basic/uuid.hpp:78:75: warning: [cppcoreguidelines-avoid-magic-numbers]

0xFF is a magic number; consider replacing it with a named constant

   78 |                                             id.bytes_[3] = ( ab >> 32 ) & 0xFF;
      |                                                                           ^

include/geode/basic/uuid.hpp:78:75: warning: [hicpp-signed-bitwise]

use of a signed integer operand with a binary bitwise operator

   78 |                                             id.bytes_[3] = ( ab >> 32 ) & 0xFF;
      |                                                                         ~ ^~~~

include/geode/basic/uuid.hpp:79:68: warning: [cppcoreguidelines-avoid-magic-numbers]

24 is a magic number; consider replacing it with a named constant

   79 |                                             id.bytes_[4] = ( ab >> 24 ) & 0xFF;
      |                                                                    ^

include/geode/basic/uuid.hpp:79:68: warning: [hicpp-signed-bitwise]

use of a signed integer operand with a binary bitwise operator

   79 |                                             id.bytes_[4] = ( ab >> 24 ) & 0xFF;
      |                                                                 ~~ ^~

include/geode/basic/uuid.hpp:79:75: warning: [cppcoreguidelines-avoid-magic-numbers]

0xFF is a magic number; consider replacing it with a named constant

   79 |                                             id.bytes_[4] = ( ab >> 24 ) & 0xFF;
      |                                                                           ^

include/geode/basic/uuid.hpp:79:75: warning: [hicpp-signed-bitwise]

use of a signed integer operand with a binary bitwise operator

   79 |                                             id.bytes_[4] = ( ab >> 24 ) & 0xFF;
      |                                                                         ~ ^~~~

include/geode/basic/uuid.hpp:80:55: warning: [cppcoreguidelines-avoid-magic-numbers]

5 is a magic number; consider replacing it with a named constant

   80 |                                             id.bytes_[5] = ( ab >> 16 ) & 0xFF;
      |                                                       ^

include/geode/basic/uuid.hpp:80:68: warning: [cppcoreguidelines-avoid-magic-numbers]

16 is a magic number; consider replacing it with a named constant

   80 |                                             id.bytes_[5] = ( ab >> 16 ) & 0xFF;
      |                                                                    ^

include/geode/basic/uuid.hpp:80:68: warning: [hicpp-signed-bitwise]

use of a signed integer operand with a binary bitwise operator

   80 |                                             id.bytes_[5] = ( ab >> 16 ) & 0xFF;
      |                                                                 ~~ ^~

include/geode/basic/uuid.hpp:80:75: warning: [cppcoreguidelines-avoid-magic-numbers]

0xFF is a magic number; consider replacing it with a named constant

   80 |                                             id.bytes_[5] = ( ab >> 16 ) & 0xFF;
      |                                                                           ^

include/geode/basic/uuid.hpp:80:75: warning: [hicpp-signed-bitwise]

use of a signed integer operand with a binary bitwise operator

   80 |                                             id.bytes_[5] = ( ab >> 16 ) & 0xFF;
      |                                                                         ~ ^~~~

include/geode/basic/uuid.hpp:81:55: warning: [cppcoreguidelines-avoid-magic-numbers]

6 is a magic number; consider replacing it with a named constant

   81 |                                             id.bytes_[6] = ( ab >> 8 ) & 0xFF;
      |                                                       ^

include/geode/basic/uuid.hpp:81:68: warning: [cppcoreguidelines-avoid-magic-numbers]

8 is a magic number; consider replacing it with a named constant

   81 |                                             id.bytes_[6] = ( ab >> 8 ) & 0xFF;
      |                                                                    ^

include/geode/basic/uuid.hpp:81:68: warning: [hicpp-signed-bitwise]

use of a signed integer operand with a binary bitwise operator

   81 |                                             id.bytes_[6] = ( ab >> 8 ) & 0xFF;
      |                                                                 ~~ ^

include/geode/basic/uuid.hpp:81:74: warning: [cppcoreguidelines-avoid-magic-numbers]

0xFF is a magic number; consider replacing it with a named constant

   81 |                                             id.bytes_[6] = ( ab >> 8 ) & 0xFF;
      |                                                                          ^

include/geode/basic/uuid.hpp:81:74: warning: [hicpp-signed-bitwise]

use of a signed integer operand with a binary bitwise operator

   81 |                                             id.bytes_[6] = ( ab >> 8 ) & 0xFF;
      |                                                                        ~ ^~~~

include/geode/basic/uuid.hpp:82:55: warning: [cppcoreguidelines-avoid-magic-numbers]

7 is a magic number; consider replacing it with a named constant

   82 |                                             id.bytes_[7] = ( ab >> 0 ) & 0xFF;
      |                                                       ^

include/geode/basic/uuid.hpp:82:68: warning: [hicpp-signed-bitwise]

use of a signed integer operand with a binary bitwise operator

   82 |                                             id.bytes_[7] = ( ab >> 0 ) & 0xFF;
      |                                                                 ~~ ^

include/geode/basic/uuid.hpp:82:74: warning: [cppcoreguidelines-avoid-magic-numbers]

0xFF is a magic number; consider replacing it with a named constant

   82 |                                             id.bytes_[7] = ( ab >> 0 ) & 0xFF;
      |                                                                          ^

include/geode/basic/uuid.hpp:82:74: warning: [hicpp-signed-bitwise]

use of a signed integer operand with a binary bitwise operator

   82 |                                             id.bytes_[7] = ( ab >> 0 ) & 0xFF;
      |                                                                        ~ ^~~~

include/geode/basic/uuid.hpp:83:55: warning: [cppcoreguidelines-avoid-magic-numbers]

8 is a magic number; consider replacing it with a named constant

   83 |                                             id.bytes_[8] = ( cd >> 56 ) & 0xFF;
      |                                                       ^

include/geode/basic/uuid.hpp:83:68: warning: [cppcoreguidelines-avoid-magic-numbers]

56 is a magic number; consider replacing it with a named constant

   83 |                                             id.bytes_[8] = ( cd >> 56 ) & 0xFF;
      |                                                                    ^

include/geode/basic/uuid.hpp:83:68: warning: [hicpp-signed-bitwise]

use of a signed integer operand with a binary bitwise operator

   83 |                                             id.bytes_[8] = ( cd >> 56 ) & 0xFF;
      |                                                                 ~~ ^~

include/geode/basic/uuid.hpp:83:75: warning: [cppcoreguidelines-avoid-magic-numbers]

0xFF is a magic number; consider replacing it with a named constant

   83 |                                             id.bytes_[8] = ( cd >> 56 ) & 0xFF;
      |                                                                           ^

include/geode/basic/uuid.hpp:83:75: warning: [hicpp-signed-bitwise]

use of a signed integer operand with a binary bitwise operator

   83 |                                             id.bytes_[8] = ( cd >> 56 ) & 0xFF;
      |                                                                         ~ ^~~~

include/geode/basic/uuid.hpp:84:55: warning: [cppcoreguidelines-avoid-magic-numbers]

9 is a magic number; consider replacing it with a named constant

   84 |                                             id.bytes_[9] = ( cd >> 48 ) & 0xFF;
      |                                                       ^

include/geode/basic/uuid.hpp:84:68: warning: [cppcoreguidelines-avoid-magic-numbers]

48 is a magic number; consider replacing it with a named constant

   84 |                                             id.bytes_[9] = ( cd >> 48 ) & 0xFF;
      |                                                                    ^

include/geode/basic/uuid.hpp:84:68: warning: [hicpp-signed-bitwise]

use of a signed integer operand with a binary bitwise operator

   84 |                                             id.bytes_[9] = ( cd >> 48 ) & 0xFF;
      |                                                                 ~~ ^~

include/geode/basic/uuid.hpp:84:75: warning: [cppcoreguidelines-avoid-magic-numbers]

0xFF is a magic number; consider replacing it with a named constant

   84 |                                             id.bytes_[9] = ( cd >> 48 ) & 0xFF;
      |                                                                           ^

include/geode/basic/uuid.hpp:84:75: warning: [hicpp-signed-bitwise]

use of a signed integer operand with a binary bitwise operator

   84 |                                             id.bytes_[9] = ( cd >> 48 ) & 0xFF;
      |                                                                         ~ ^~~~

include/geode/basic/uuid.hpp:85:55: warning: [cppcoreguidelines-avoid-magic-numbers]

10 is a magic number; consider replacing it with a named constant

   85 |                                             id.bytes_[10] = ( cd >> 40 ) & 0xFF;
      |                                                       ^

include/geode/basic/uuid.hpp:85:69: warning: [cppcoreguidelines-avoid-magic-numbers]

40 is a magic number; consider replacing it with a named constant

   85 |                                             id.bytes_[10] = ( cd >> 40 ) & 0xFF;
      |                                                                     ^

include/geode/basic/uuid.hpp:85:69: warning: [hicpp-signed-bitwise]

use of a signed integer operand with a binary bitwise operator

   85 |                                             id.bytes_[10] = ( cd >> 40 ) & 0xFF;
      |                                                                  ~~ ^~

include/geode/basic/uuid.hpp:85:76: warning: [cppcoreguidelines-avoid-magic-numbers]

0xFF is a magic number; consider replacing it with a named constant

   85 |                                             id.bytes_[10] = ( cd >> 40 ) & 0xFF;
      |                                                                            ^

include/geode/basic/uuid.hpp:85:76: warning: [hicpp-signed-bitwise]

use of a signed integer operand with a binary bitwise operator

   85 |                                             id.bytes_[10] = ( cd >> 40 ) & 0xFF;
      |                                                                          ~ ^~~~

include/geode/basic/uuid.hpp:86:55: warning: [cppcoreguidelines-avoid-magic-numbers]

11 is a magic number; consider replacing it with a named constant

   86 |                                             id.bytes_[11] = ( cd >> 32 ) & 0xFF;
      |                                                       ^

include/geode/basic/uuid.hpp:86:69: warning: [cppcoreguidelines-avoid-magic-numbers]

32 is a magic number; consider replacing it with a named constant

   86 |                                             id.bytes_[11] = ( cd >> 32 ) & 0xFF;
      |                                                                     ^

include/geode/basic/uuid.hpp:86:69: warning: [hicpp-signed-bitwise]

use of a signed integer operand with a binary bitwise operator

   86 |                                             id.bytes_[11] = ( cd >> 32 ) & 0xFF;
      |                                                                  ~~ ^~

include/geode/basic/uuid.hpp:86:76: warning: [cppcoreguidelines-avoid-magic-numbers]

0xFF is a magic number; consider replacing it with a named constant

   86 |                                             id.bytes_[11] = ( cd >> 32 ) & 0xFF;
      |                                                                            ^

include/geode/basic/uuid.hpp:86:76: warning: [hicpp-signed-bitwise]

use of a signed integer operand with a binary bitwise operator

   86 |                                             id.bytes_[11] = ( cd >> 32 ) & 0xFF;
      |                                                                          ~ ^~~~

include/geode/basic/uuid.hpp:87:55: warning: [cppcoreguidelines-avoid-magic-numbers]

12 is a magic number; consider replacing it with a named constant

   87 |                                             id.bytes_[12] = ( cd >> 24 ) & 0xFF;
      |                                                       ^

include/geode/basic/uuid.hpp:87:69: warning: [cppcoreguidelines-avoid-magic-numbers]

24 is a magic number; consider replacing it with a named constant

   87 |                                             id.bytes_[12] = ( cd >> 24 ) & 0xFF;
      |                                                                     ^

include/geode/basic/uuid.hpp:87:69: warning: [hicpp-signed-bitwise]

use of a signed integer operand with a binary bitwise operator

   87 |                                             id.bytes_[12] = ( cd >> 24 ) & 0xFF;
      |                                                                  ~~ ^~

include/geode/basic/uuid.hpp:87:76: warning: [cppcoreguidelines-avoid-magic-numbers]

0xFF is a magic number; consider replacing it with a named constant

   87 |                                             id.bytes_[12] = ( cd >> 24 ) & 0xFF;
      |                                                                            ^

include/geode/basic/uuid.hpp:87:76: warning: [hicpp-signed-bitwise]

use of a signed integer operand with a binary bitwise operator

   87 |                                             id.bytes_[12] = ( cd >> 24 ) & 0xFF;
      |                                                                          ~ ^~~~

include/geode/basic/uuid.hpp:88:55: warning: [cppcoreguidelines-avoid-magic-numbers]

13 is a magic number; consider replacing it with a named constant

   88 |                                             id.bytes_[13] = ( cd >> 16 ) & 0xFF;
      |                                                       ^

include/geode/basic/uuid.hpp:88:69: warning: [cppcoreguidelines-avoid-magic-numbers]

16 is a magic number; consider replacing it with a named constant

   88 |                                             id.bytes_[13] = ( cd >> 16 ) & 0xFF;
      |                                                                     ^

include/geode/basic/uuid.hpp:88:69: warning: [hicpp-signed-bitwise]

use of a signed integer operand with a binary bitwise operator

   88 |                                             id.bytes_[13] = ( cd >> 16 ) & 0xFF;
      |                                                                  ~~ ^~

include/geode/basic/uuid.hpp:88:76: warning: [cppcoreguidelines-avoid-magic-numbers]

0xFF is a magic number; consider replacing it with a named constant

   88 |                                             id.bytes_[13] = ( cd >> 16 ) & 0xFF;
      |                                                                            ^

include/geode/basic/uuid.hpp:88:76: warning: [hicpp-signed-bitwise]

use of a signed integer operand with a binary bitwise operator

   88 |                                             id.bytes_[13] = ( cd >> 16 ) & 0xFF;
      |                                                                          ~ ^~~~

include/geode/basic/uuid.hpp:89:55: warning: [cppcoreguidelines-avoid-magic-numbers]

14 is a magic number; consider replacing it with a named constant

   89 |                                             id.bytes_[14] = ( cd >> 8 ) & 0xFF;
      |                                                       ^

include/geode/basic/uuid.hpp:89:69: warning: [cppcoreguidelines-avoid-magic-numbers]

8 is a magic number; consider replacing it with a named constant

   89 |                                             id.bytes_[14] = ( cd >> 8 ) & 0xFF;
      |                                                                     ^

include/geode/basic/uuid.hpp:89:69: warning: [hicpp-signed-bitwise]

use of a signed integer operand with a binary bitwise operator

   89 |                                             id.bytes_[14] = ( cd >> 8 ) & 0xFF;
      |                                                                  ~~ ^

include/geode/basic/uuid.hpp:89:75: warning: [cppcoreguidelines-avoid-magic-numbers]

0xFF is a magic number; consider replacing it with a named constant

   89 |                                             id.bytes_[14] = ( cd >> 8 ) & 0xFF;
      |                                                                           ^

include/geode/basic/uuid.hpp:89:75: warning: [hicpp-signed-bitwise]

use of a signed integer operand with a binary bitwise operator

   89 |                                             id.bytes_[14] = ( cd >> 8 ) & 0xFF;
      |                                                                         ~ ^~~~

include/geode/basic/uuid.hpp:90:55: warning: [cppcoreguidelines-avoid-magic-numbers]

15 is a magic number; consider replacing it with a named constant

   90 |                                             id.bytes_[15] = ( cd >> 0 ) & 0xFF;
      |                                                       ^

include/geode/basic/uuid.hpp:90:69: warning: [hicpp-signed-bitwise]

use of a signed integer operand with a binary bitwise operator

   90 |                                             id.bytes_[15] = ( cd >> 0 ) & 0xFF;
      |                                                                  ~~ ^

include/geode/basic/uuid.hpp:90:75: warning: [cppcoreguidelines-avoid-magic-numbers]

0xFF is a magic number; consider replacing it with a named constant

   90 |                                             id.bytes_[15] = ( cd >> 0 ) & 0xFF;
      |                                                                           ^

include/geode/basic/uuid.hpp:90:75: warning: [hicpp-signed-bitwise]

use of a signed integer operand with a binary bitwise operator

   90 |                                             id.bytes_[15] = ( cd >> 0 ) & 0xFF;
      |                                                                         ~ ^~~~

include/geode/basic/uuid.hpp:92:72: warning: [readability-identifier-length]

parameter name 'id' is too short, expected at least 3 characters

   92 |                                            []( Archive &archive, uuid &id ) {
      |                                                                        ^

include/geode/basic/variable_attribute.hpp:113:30: warning: [cppcoreguidelines-avoid-magic-numbers]

10 is a magic number; consider replacing it with a named constant
```
  113 |             values_.reserve( 10 );
      |                              ^
```
include/geode/basic/variable_attribute.hpp:136:30: warning: [cppcoreguidelines-avoid-magic-numbers]

10 is a magic number; consider replacing it with a named constant
```
  136 |             values_.reserve( 10 );
      |                              ^
```
include/geode/basic/variable_attribute.hpp:282:31: warning: [readability-identifier-length]

variable name 'in' is too short, expected at least 3 characters
```
  282 |             for( const auto& [in, outs] : old2new_mapping.in2out_map() )
      |                               ^
```
include/geode/basic/variable_attribute.hpp:316:20: warning: [cppcoreguidelines-pro-type-reinterpret-cast]

do not use reinterpret_cast
```
  316 |             return reinterpret_cast< const bool& >( values_[element] );
      |                    ^
```

Have any feedback or feature suggestions? Share it here.

feat(Exception): new exception at library scope

a29dc7c

BREAKING CHANGE: EXCEPTION and ASSERT macros are removed

francoisbonneau reviewed Apr 23, 2026

View reviewed changes

Comment thread include/geode/basic/pimpl.hpp

panquez approved these changes Apr 24, 2026

View reviewed changes

Comment thread include/geode/basic/variable_attribute.hpp

BotellaA added 3 commits April 24, 2026 14:04

complete implementation

3b06fa9

tidy v1

a844050

fix

27ef94b

BotellaA marked this pull request as ready for review April 24, 2026 12:58

BotellaA added 3 commits April 24, 2026 15:26

tidy v2

b6ccdca

fix

039134d

fix

a6f92d2

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Uh oh!

feat(Exception): new exception at library scope#1264

feat(Exception): new exception at library scope#1264
BotellaA wants to merge 7 commits intonextfrom
feat/exception-library

BotellaA commented Apr 23, 2026

Uh oh!

github-actions Bot commented Apr 23, 2026 •

edited

Loading

Uh oh!

Uh oh!

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

3 participants

Uh oh!

Conversation

BotellaA commented Apr 23, 2026

Uh oh!

github-actions Bot commented Apr 23, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Cpp-Linter Report ⚠️

Uh oh!

Uh oh!

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

3 participants

github-actions Bot commented Apr 23, 2026 •

edited

Loading