fix(AttributeManager): remove import method taking span by BenPinet · Pull Request #1322 · Geode-solutions/OpenGeode

BenPinet · 2026-08-14T12:11:25Z

No description provided.

github-actions · 2026-08-14T12:21:06Z

Cpp-Linter Report ⚠️

Some files did not pass the configured checks!

clang-tidy (v21.1.8) reports: 244 concern(s)

include/geode/basic/attribute.hpp:52: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
```
   52 |     class AttributeBase : public Identifier
      |           ^
```
include/geode/basic/attribute.hpp:82: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()
```
   82 |             properties_ = std::move( new_properties );
      |                           ^~~~~~~~~~                ~
```
include/geode/basic/attribute.hpp:152:28: warning: [hicpp-move-const-arg]

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

single-argument constructors must be marked explicit to avoid unintentional implicit conversions
```
  121 |         ConstantAttribute( std::string_view name )
      |         ^
      |         explicit 
```

include/geode/basic/sparse_attribute.hpp:89:24: warning: [readability-simplify-boolean-expr]

redundant boolean literal in conditional return statement

   87 |             if( value( element ) == default_values_.no_value )
      |             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
      |             return static_cast<bool>(value( element ) != default_values_.no_value)
   88 |             {
      |             ~
   89 |                 return false;
      |                 ~~~~~~~^~~~~~
   90 |             }
      |             ~
   91 |             return true;
      |             ~~~~~~~~~~~

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

10 is a magic number; consider replacing it with a named constant
```
  134 |             values_.reserve( 10 );
      |                              ^
```
include/geode/basic/sparse_attribute.hpp:137:9: warning: [google-explicit-constructor]

single-argument constructors must be marked explicit to avoid unintentional implicit conversions
```
  137 |         SparseAttribute( std::string_view name )
      |         ^
      |         explicit 
```

include/geode/basic/sparse_attribute.hpp:164:62: warning: [readability-identifier-length]

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

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

include/geode/basic/sparse_attribute.hpp:178:65: warning: [readability-identifier-length]

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

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

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

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

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

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

include/geode/basic/variable_attribute.hpp:78:24: warning: [readability-simplify-boolean-expr]

redundant boolean literal in conditional return statement

   76 |             if( values_[element] == default_values_.no_value )
      |             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
      |             return static_cast<bool>(values_[element] != default_values_.no_value)
   77 |             {
      |             ~
   78 |                 return false;
      |                 ~~~~~~~^~~~~~
   79 |             }
      |             ~
   80 |             return true;
      |             ~~~~~~~~~~~

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

10 is a magic number; consider replacing it with a named constant
```
  126 |             values_.reserve( 10 );
      |                              ^
```
include/geode/basic/variable_attribute.hpp:129:9: warning: [google-explicit-constructor]

single-argument constructors must be marked explicit to avoid unintentional implicit conversions
```
  129 |         VariableAttribute( std::string_view name )
      |         ^
      |         explicit 
```
include/geode/basic/variable_attribute.hpp:167:30: warning: [cppcoreguidelines-avoid-magic-numbers]

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

variable name 'in' is too short, expected at least 3 characters
```
  301 |             for( const auto& [in, outs] : old2new_mapping.in2out_map() )
      |                               ^
```
include/geode/basic/variable_attribute.hpp:330:55: warning: [hicpp-move-const-arg]

std::move of the variable 'properties' of the trivially-copyable type 'AttributeProperties' has no effect; remove std::move()
```
  330 |             : VariableAttribute( default_value, name, std::move( properties ) )
      |                                                       ^~~~~~~~~~            ~
```
include/geode/basic/variable_attribute.hpp:336:20: warning: [cppcoreguidelines-pro-type-reinterpret-cast]

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

include/geode/basic/variable_attribute.hpp:343:24: warning: [readability-simplify-boolean-expr]

redundant boolean literal in conditional return statement

  341 |             if( value( element ) == default_values_.no_value )
      |             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
      |             return value( element ) != default_values_.no_value
  342 |             {
      |             ~
  343 |                 return false;
      |                 ~~~~~~~^~~~~~
  344 |             }
      |             ~
  345 |             return true;
      |             ~~~~~~~~~~~

include/geode/basic/variable_attribute.hpp:350:32: warning: [hicpp-move-const-arg]

std::move of the variable 'value' of the trivially-copyable type 'bool' has no effect; remove std::move()
```
  350 |             values_[element] = std::move( value );
      |                                ^~~~~~~~~~       ~
```

include/geode/basic/variable_attribute.hpp:350:32: warning: [readability-implicit-bool-conversion]

implicit conversion 'bool' -> 'value_type' (aka 'unsigned char')

  350 |             values_[element] = std::move( value );
      |                                ^                 
      |                                static_cast<value_type>( )

include/geode/basic/variable_attribute.hpp:361:23: warning: [cppcoreguidelines-pro-type-reinterpret-cast]

do not use reinterpret_cast
```
  361 |             modifier( reinterpret_cast< bool& >( values_[element] ) );
      |                       ^
```
include/geode/basic/variable_attribute.hpp:388:48: warning: [hicpp-move-const-arg]

std::move of the variable 'properties' of the trivially-copyable type 'AttributeProperties' has no effect; remove std::move()
```
  388 |             : ReadOnlyAttribute< bool >( name, std::move( properties ) ),
      |                                                ^~~~~~~~~~            ~
```
include/geode/basic/variable_attribute.hpp:391:30: warning: [cppcoreguidelines-avoid-magic-numbers]

10 is a magic number; consider replacing it with a named constant
```
  391 |             values_.reserve( 10 );
      |                              ^
```
include/geode/basic/variable_attribute.hpp:394:9: warning: [cppcoreguidelines-pro-type-member-init]

constructor does not initialize these fields: default_values_
```
  394 |         VariableAttribute( std::string_view name )
      |         ^
```
include/geode/basic/variable_attribute.hpp:394:9: warning: [google-explicit-constructor]

single-argument constructors must be marked explicit to avoid unintentional implicit conversions
```
  394 |         VariableAttribute( std::string_view name )
      |         ^
      |         explicit 
```
include/geode/basic/variable_attribute.hpp:397:9: warning: [cppcoreguidelines-pro-type-member-init]

constructor does not initialize these fields: default_values_
```
  397 |         VariableAttribute()
      |         ^
```

include/geode/basic/variable_attribute.hpp:409:31: warning: [cppcoreguidelines-init-variables]

variable 'old_value' is not initialized

  409 |                          bool old_value;
      |                               ^        
      |                                         = false

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

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

include/geode/basic/variable_attribute.hpp:467:38: warning: [bugprone-unchecked-optional-access]

unchecked access to optional value

  467 |                     default_values_, this->name().value(), this->properties() }
      |                                      ^~~~~~~~~~~~

include/geode/basic/variable_attribute.hpp:485:34: warning: [readability-implicit-bool-conversion]

implicit conversion 'bool' -> 'value_type' (aka 'unsigned char')

  485 |                     values_[i] = typed_attribute.value( i );
      |                                  ^                         
      |                                  static_cast<value_type>(  )

include/geode/basic/variable_attribute.hpp:497:38: warning: [bugprone-unchecked-optional-access]

unchecked access to optional value

  497 |                     default_values_, this->name().value(), this->properties() }
      |                                      ^~~~~~~~~~~~

include/geode/basic/variable_attribute.hpp:528:38: warning: [bugprone-unchecked-optional-access]

unchecked access to optional value

  528 |                     default_values_, this->name().value(), this->properties() }
      |                                      ^~~~~~~~~~~~

include/geode/basic/variable_attribute.hpp:532:31: warning: [readability-identifier-length]

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

variable name 'in' is too short, expected at least 3 characters
```
  562 |             for( const auto& [in, outs] : old2new_mapping.in2out_map() )
      |                               ^
```
include/geode/basic/variable_attribute.hpp:573:45: warning: [readability-redundant-member-init]

initializer for member 'values_' is redundant
```
  573 |         std::vector< unsigned char > values_{};
      |                                             ^~
```
src/geode/basic/attribute_manager.cpp:318:18: warning: [readability-identifier-length]

variable name 'it' is too short, expected at least 3 characters
```
  318 |             auto it = attribute_manager.attributes_.find( attribute_id );
      |                  ^
```
src/geode/basic/attribute_manager.cpp:460:9: warning: [readability-avoid-return-with-void-value]

return statement within a void function should not have a specified return value
```
  460 |         return impl_->register_attribute(
      |         ^~~~~~
```

src/geode/mesh/helpers/internal/copy.cpp:30:1: warning: [modernize-concat-nested-namespaces]

nested namespaces can be concatenated

   30 | namespace geode
      | ^~~~~~~~~~~~~~~
   31 | {
      | ~
   32 |     namespace internal
      |     ~~~~~~~~~~~~~~~~~~
      |     namespace geode::internal
   33 |     {
   34 |         void copy_attributes(
   35 |             const AttributeManager& manager_in, AttributeManager& manager_out )
   36 |         {
   37 |             GenericMapping< index_t > mapping;
   38 |             for( const auto attribute_element :
   39 |                 geode::Range{ manager_in.nb_elements() } )
   40 |             {
   41 |                 mapping.map( attribute_element, attribute_element );
   42 |             }
   43 |             manager_out.import( manager_in, mapping );
   44 |         }
   45 |     } // namespace internal
      |     ~~~~~~~~~~~~~~~~~~~~~~~
      |     } // namespace geode::internal

tests/basic/test-attribute.cpp:48:5: warning: [modernize-use-nodiscard]

function 'generic_value' should be marked [[nodiscard]]
```
   48 |     float generic_value() const
      |     ^
      |     [[nodiscard]] 
```
tests/basic/test-attribute.cpp:109:6: warning: [misc-use-internal-linkage]

function 'test_constant_attribute' can be made static or moved into an anonymous namespace to enforce internal linkage
```
  109 | void test_constant_attribute(
      |      ^
      | static 
```

tests/basic/test-attribute.cpp:116:5: warning: [cppcoreguidelines-pro-type-member-init]

uninitialized record type: 'attribute_values'

  116 |     geode::AttributeValues< bool > attribute_values;
      |     ^                                              
      |                                                    {}

tests/basic/test-attribute.cpp:127:48: warning: [readability-simplify-boolean-expr]

redundant boolean literal supplied to boolean operator

  127 |         constant_attribute->default_value() == true, "Wrong default value" );
      |         ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^~~~
      |         constant_attribute->default_value()

tests/basic/test-attribute.cpp:138:28: warning: [cppcoreguidelines-avoid-magic-numbers]

12 is a magic number; consider replacing it with a named constant
```
  138 |         !attribute->value( 12 ), "Should be equal to false" );
      |                            ^
```
tests/basic/test-attribute.cpp:141:6: warning: [misc-use-internal-linkage]

function 'test_foo_constant_attribute' can be made static or moved into an anonymous namespace to enforce internal linkage
```
  141 | void test_foo_constant_attribute(
      |      ^
      | static 
```
tests/basic/test-attribute.cpp:156:23: warning: [cppcoreguidelines-avoid-magic-numbers]

12.4 is a magic number; consider replacing it with a named constant
```
  156 |         foo.double_ = 12.4;
      |                       ^
```
tests/basic/test-attribute.cpp:159:48: warning: [cppcoreguidelines-avoid-magic-numbers]

12.4 is a magic number; consider replacing it with a named constant
```
  159 |         constant_attribute->value().double_ == 12.4,
      |                                                ^
```
tests/basic/test-attribute.cpp:163:6: warning: [misc-use-internal-linkage]

function 'test_foo_variable_attribute' can be made static or moved into an anonymous namespace to enforce internal linkage
```
  163 | void test_foo_variable_attribute(
      |      ^
      | static 
```
tests/basic/test-attribute.cpp:192:23: warning: [cppcoreguidelines-avoid-magic-numbers]

12.4 is a magic number; consider replacing it with a named constant
```
  192 |         foo.double_ = 12.4;
      |                       ^
```
tests/basic/test-attribute.cpp:197:51: warning: [cppcoreguidelines-avoid-magic-numbers]

12.4 is a magic number; consider replacing it with a named constant
```
  197 |         variable_attribute->value( 3 ).double_ == 12.4,
      |                                                   ^
```
tests/basic/test-attribute.cpp:201:6: warning: [misc-use-internal-linkage]

function 'test_int_variable_attribute' can be made static or moved into an anonymous namespace to enforce internal linkage
```
  201 | void test_int_variable_attribute(
      |      ^
      | static 
```

tests/basic/test-attribute.cpp:208:5: warning: [cppcoreguidelines-pro-type-member-init]

uninitialized record type: 'attribute_values'

  208 |     geode::AttributeValues< int > attribute_values;
      |     ^                                             
      |                                                   {}

tests/basic/test-attribute.cpp:209:38: warning: [cppcoreguidelines-avoid-magic-numbers]

12 is a magic number; consider replacing it with a named constant
```
  209 |     attribute_values.default_value = 12;
      |                                      ^
```
tests/basic/test-attribute.cpp:210:33: warning: [bugprone-narrowing-conversions]

narrowing conversion from constant value 4294967295 (0xFFFFFFFF) of type 'index_t' (aka 'unsigned int') to signed type 'int' is implementation-defined
```
  210 |     attribute_values.no_value = geode::NO_ID;
      |                                 ^
```
tests/basic/test-attribute.cpp:216:63: warning: [cppcoreguidelines-avoid-magic-numbers]

12 is a magic number; consider replacing it with a named constant
```
  216 |         variable_attribute->default_values().default_value == 12,
      |                                                               ^
```

tests/basic/test-attribute.cpp:224:61: warning: [cppcoreguidelines-avoid-magic-numbers]

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

  224 |     geode::OpenGeodeBasicException::test( attribute->value( 6 ) == 12,
      |                                                             ^

tests/basic/test-attribute.cpp:224:68: warning: [cppcoreguidelines-avoid-magic-numbers]

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

  224 |     geode::OpenGeodeBasicException::test( attribute->value( 6 ) == 12,
      |                                                                    ^

tests/basic/test-attribute.cpp:227:39: warning: [cppcoreguidelines-avoid-magic-numbers]

5 is a magic number; consider replacing it with a named constant
```
  227 |     variable_attribute->set_value( 3, 5 );
      |                                       ^
```

tests/basic/test-attribute.cpp:228:68: warning: [cppcoreguidelines-avoid-magic-numbers]

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

  228 |     geode::OpenGeodeBasicException::test( attribute->value( 3 ) == 5,
      |                                                                    ^

tests/basic/test-attribute.cpp:232:6: warning: [misc-use-internal-linkage]

function 'test_foo_sparse_attribute' can be made static or moved into an anonymous namespace to enforce internal linkage
```
  232 | void test_foo_sparse_attribute(
      |      ^
      | static 
```
tests/basic/test-attribute.cpp:247:23: warning: [cppcoreguidelines-avoid-magic-numbers]

12.4 is a magic number; consider replacing it with a named constant
```
  247 |         foo.double_ = 12.4;
      |                       ^
```
tests/basic/test-attribute.cpp:255:49: warning: [cppcoreguidelines-avoid-magic-numbers]

12.4 is a magic number; consider replacing it with a named constant
```
  255 |         sparse_attribute->value( 3 ).double_ == 12.4,
      |                                                 ^
```
tests/basic/test-attribute.cpp:262:6: warning: [misc-use-internal-linkage]

function 'test_double_sparse_attribute' can be made static or moved into an anonymous namespace to enforce internal linkage
```
  262 | void test_double_sparse_attribute(
      |      ^
      | static 
```

tests/basic/test-attribute.cpp:269:5: warning: [cppcoreguidelines-pro-type-member-init]

uninitialized record type: 'attribute_values'

  269 |     geode::AttributeValues< double > attribute_values;
      |     ^                                                
      |                                                      {}

tests/basic/test-attribute.cpp:270:38: warning: [cppcoreguidelines-avoid-magic-numbers]
1. is a magic number; consider replacing it with a named constant
```
  270 |     attribute_values.default_value = 12.;
      |                                      ^
```
tests/basic/test-attribute.cpp:278:61: warning: [cppcoreguidelines-avoid-magic-numbers]

12 is a magic number; consider replacing it with a named constant
```
  278 |         sparse_attribute->default_values().default_value == 12,
      |                                                             ^
```
tests/basic/test-attribute.cpp:281:34: warning: [cppcoreguidelines-avoid-magic-numbers]

7 is a magic number; consider replacing it with a named constant
```
  281 |     sparse_attribute->set_value( 7, 7 );
      |                                  ^
```
tests/basic/test-attribute.cpp:281:37: warning: [cppcoreguidelines-avoid-magic-numbers]

7 is a magic number; consider replacing it with a named constant
```
  281 |     sparse_attribute->set_value( 7, 7 );
      |                                     ^
```

tests/basic/test-attribute.cpp:283:49: warning: [cppcoreguidelines-avoid-magic-numbers]

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

  283 |     manager.interpolate_attribute_value( { { 1, 7 }, { 0.5, 0.3 } }, 4 );
      |                                                 ^

tests/basic/test-attribute.cpp:283:56: warning: [cppcoreguidelines-avoid-magic-numbers]

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

  283 |     manager.interpolate_attribute_value( { { 1, 7 }, { 0.5, 0.3 } }, 4 );
      |                                                        ^

tests/basic/test-attribute.cpp:283:61: warning: [cppcoreguidelines-avoid-magic-numbers]

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

  283 |     manager.interpolate_attribute_value( { { 1, 7 }, { 0.5, 0.3 } }, 4 );
      |                                                             ^

tests/basic/test-attribute.cpp:291:34: warning: [cppcoreguidelines-avoid-magic-numbers]

8.1 is a magic number; consider replacing it with a named constant
```
  291 |         attribute->value( 4 ) == 8.1, "Should be equal to 8.1" );
      |                                  ^
```
tests/basic/test-attribute.cpp:293:27: warning: [cppcoreguidelines-avoid-magic-numbers]

6 is a magic number; consider replacing it with a named constant
```
  293 |         attribute->value( 6 ) == 12, "Should be equal to 12" );
      |                           ^
```
tests/basic/test-attribute.cpp:293:34: warning: [cppcoreguidelines-avoid-magic-numbers]

12 is a magic number; consider replacing it with a named constant
```
  293 |         attribute->value( 6 ) == 12, "Should be equal to 12" );
      |                                  ^
```
tests/basic/test-attribute.cpp:295:27: warning: [cppcoreguidelines-avoid-magic-numbers]

7 is a magic number; consider replacing it with a named constant
```
  295 |         attribute->value( 7 ) == 7, "Should be equal to 7" );
      |                           ^
```
tests/basic/test-attribute.cpp:295:34: warning: [cppcoreguidelines-avoid-magic-numbers]

7 is a magic number; consider replacing it with a named constant
```
  295 |         attribute->value( 7 ) == 7, "Should be equal to 7" );
      |                                  ^
```
tests/basic/test-attribute.cpp:297:37: warning: [cppcoreguidelines-avoid-magic-numbers]

5 is a magic number; consider replacing it with a named constant
```
  297 |     sparse_attribute->set_value( 3, 5 );
      |                                     ^
```
tests/basic/test-attribute.cpp:299:34: warning: [cppcoreguidelines-avoid-magic-numbers]

5 is a magic number; consider replacing it with a named constant
```
  299 |         attribute->value( 3 ) == 5, "Should be equal to 5" );
      |                                  ^
```
tests/basic/test-attribute.cpp:302:6: warning: [misc-use-internal-linkage]

function 'test_double_array_attribute' can be made static or moved into an anonymous namespace to enforce internal linkage
```
  302 | void test_double_array_attribute( geode::AttributeManager& manager )
      |      ^
      | static 
```

tests/basic/test-attribute.cpp:308:5: warning: [cppcoreguidelines-pro-type-member-init]

uninitialized record type: 'attribute_values'

  308 |     geode::AttributeValues< std::array< double, 3 > > attribute_values;
      |     ^                                                                 
      |                                                                       {}

tests/basic/test-attribute.cpp:309:42: warning: [cppcoreguidelines-avoid-magic-numbers]
1. is a magic number; consider replacing it with a named constant
```
  309 |     attribute_values.default_value = { { 10., 11., 12. } };
      |                                          ^
```
tests/basic/test-attribute.cpp:309:47: warning: [cppcoreguidelines-avoid-magic-numbers]
1. is a magic number; consider replacing it with a named constant
```
  309 |     attribute_values.default_value = { { 10., 11., 12. } };
      |                                               ^
```
tests/basic/test-attribute.cpp:309:52: warning: [cppcoreguidelines-avoid-magic-numbers]
1. is a magic number; consider replacing it with a named constant
```
  309 |     attribute_values.default_value = { { 10., 11., 12. } };
      |                                                    ^
```

tests/basic/test-attribute.cpp:318:63: warning: [cppcoreguidelines-avoid-magic-numbers]

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

  318 |         array_attribute->default_values().default_value[0] == 10.,
      |                                                               ^

tests/basic/test-attribute.cpp:321:63: warning: [cppcoreguidelines-avoid-magic-numbers]

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

  321 |         array_attribute->default_values().default_value[1] == 11.,
      |                                                               ^

tests/basic/test-attribute.cpp:324:63: warning: [cppcoreguidelines-avoid-magic-numbers]

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

  324 |         array_attribute->default_values().default_value[2] == 12.,
      |                                                               ^

tests/basic/test-attribute.cpp:326:44: warning: [cppcoreguidelines-avoid-magic-numbers]
1. is a magic number; consider replacing it with a named constant
```
  326 |     array_attribute->set_value( 3, { { 1., 2., 3. } } );
      |                                            ^
```
tests/basic/test-attribute.cpp:326:48: warning: [cppcoreguidelines-avoid-magic-numbers]
1. is a magic number; consider replacing it with a named constant
```
  326 |     array_attribute->set_value( 3, { { 1., 2., 3. } } );
      |                                                ^
```
tests/basic/test-attribute.cpp:327:33: warning: [cppcoreguidelines-avoid-magic-numbers]

7 is a magic number; consider replacing it with a named constant
```
  327 |     array_attribute->set_value( 7, { { 2., 5., 7. } } );
      |                                 ^
```
tests/basic/test-attribute.cpp:327:40: warning: [cppcoreguidelines-avoid-magic-numbers]
1. is a magic number; consider replacing it with a named constant
```
  327 |     array_attribute->set_value( 7, { { 2., 5., 7. } } );
      |                                        ^
```
tests/basic/test-attribute.cpp:327:44: warning: [cppcoreguidelines-avoid-magic-numbers]
1. is a magic number; consider replacing it with a named constant
```
  327 |     array_attribute->set_value( 7, { { 2., 5., 7. } } );
      |                                            ^
```
tests/basic/test-attribute.cpp:327:48: warning: [cppcoreguidelines-avoid-magic-numbers]
1. is a magic number; consider replacing it with a named constant
```
  327 |     array_attribute->set_value( 7, { { 2., 5., 7. } } );
      |                                                ^
```

tests/basic/test-attribute.cpp:329:49: warning: [cppcoreguidelines-avoid-magic-numbers]

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

  329 |     manager.interpolate_attribute_value( { { 1, 7 }, { 0.5, 0.3 } }, 4 );
      |                                                 ^

tests/basic/test-attribute.cpp:329:56: warning: [cppcoreguidelines-avoid-magic-numbers]

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

  329 |     manager.interpolate_attribute_value( { { 1, 7 }, { 0.5, 0.3 } }, 4 );
      |                                                        ^

tests/basic/test-attribute.cpp:329:61: warning: [cppcoreguidelines-avoid-magic-numbers]

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

  329 |     manager.interpolate_attribute_value( { { 1, 7 }, { 0.5, 0.3 } }, 4 );
      |                                                             ^

tests/basic/test-attribute.cpp:336:71: warning: [cppcoreguidelines-avoid-magic-numbers]

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

  336 |     geode::OpenGeodeBasicException::test( attribute->value( 2 )[1] == 2.,
      |                                                                       ^

tests/basic/test-attribute.cpp:338:71: warning: [cppcoreguidelines-avoid-magic-numbers]

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

  338 |     geode::OpenGeodeBasicException::test( attribute->value( 2 )[2] == 3.,
      |                                                                       ^

tests/basic/test-attribute.cpp:342:71: warning: [cppcoreguidelines-avoid-magic-numbers]

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

  342 |     geode::OpenGeodeBasicException::test( attribute->value( 3 )[1] == 2.,
      |                                                                       ^

tests/basic/test-attribute.cpp:344:71: warning: [cppcoreguidelines-avoid-magic-numbers]

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

  344 |     geode::OpenGeodeBasicException::test( attribute->value( 3 )[2] == 3.,
      |                                                                       ^

tests/basic/test-attribute.cpp:346:71: warning: [cppcoreguidelines-avoid-magic-numbers]

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

  346 |     geode::OpenGeodeBasicException::test( attribute->value( 4 )[0] == 5.6,
      |                                                                       ^

tests/basic/test-attribute.cpp:348:71: warning: [cppcoreguidelines-avoid-magic-numbers]

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

  348 |     geode::OpenGeodeBasicException::test( attribute->value( 4 )[1] == 7.,
      |                                                                       ^

tests/basic/test-attribute.cpp:350:71: warning: [cppcoreguidelines-avoid-magic-numbers]

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

  350 |     geode::OpenGeodeBasicException::test( attribute->value( 4 )[2] == 8.1,
      |                                                                       ^

tests/basic/test-attribute.cpp:352:61: warning: [cppcoreguidelines-avoid-magic-numbers]

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

  352 |     geode::OpenGeodeBasicException::test( attribute->value( 6 )[0] == 10.,
      |                                                             ^

tests/basic/test-attribute.cpp:352:71: warning: [cppcoreguidelines-avoid-magic-numbers]

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

  352 |     geode::OpenGeodeBasicException::test( attribute->value( 6 )[0] == 10.,
      |                                                                       ^

tests/basic/test-attribute.cpp:353:71: warning: [cppcoreguidelines-avoid-magic-numbers]

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

  353 |         "Value [6,0] Should be equal to 10., not ", attribute->value( 6 )[0] );
      |                                                                       ^

tests/basic/test-attribute.cpp:354:61: warning: [cppcoreguidelines-avoid-magic-numbers]

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

  354 |     geode::OpenGeodeBasicException::test( attribute->value( 6 )[1] == 11.,
      |                                                             ^

tests/basic/test-attribute.cpp:354:71: warning: [cppcoreguidelines-avoid-magic-numbers]

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

  354 |     geode::OpenGeodeBasicException::test( attribute->value( 6 )[1] == 11.,
      |                                                                       ^

tests/basic/test-attribute.cpp:355:71: warning: [cppcoreguidelines-avoid-magic-numbers]

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

  355 |         "Value [6,1] Should be equal to 11., not ", attribute->value( 6 )[1] );
      |                                                                       ^

tests/basic/test-attribute.cpp:356:61: warning: [cppcoreguidelines-avoid-magic-numbers]

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

  356 |     geode::OpenGeodeBasicException::test( attribute->value( 6 )[2] == 12.,
      |                                                             ^

tests/basic/test-attribute.cpp:356:71: warning: [cppcoreguidelines-avoid-magic-numbers]

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

  356 |     geode::OpenGeodeBasicException::test( attribute->value( 6 )[2] == 12.,
      |                                                                       ^

tests/basic/test-attribute.cpp:357:71: warning: [cppcoreguidelines-avoid-magic-numbers]

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

  357 |         "Value [6,2] Should be equal to 12., not ", attribute->value( 6 )[2] );
      |                                                                       ^

tests/basic/test-attribute.cpp:358:61: warning: [cppcoreguidelines-avoid-magic-numbers]

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

  358 |     geode::OpenGeodeBasicException::test( attribute->value( 7 )[0] == 2.,
      |                                                             ^

tests/basic/test-attribute.cpp:358:71: warning: [cppcoreguidelines-avoid-magic-numbers]

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

  358 |     geode::OpenGeodeBasicException::test( attribute->value( 7 )[0] == 2.,
      |                                                                       ^

tests/basic/test-attribute.cpp:359:70: warning: [cppcoreguidelines-avoid-magic-numbers]

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

  359 |         "Value [7,0] Should be equal to 2., not ", attribute->value( 7 )[0] );
      |                                                                      ^

tests/basic/test-attribute.cpp:360:61: warning: [cppcoreguidelines-avoid-magic-numbers]

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

  360 |     geode::OpenGeodeBasicException::test( attribute->value( 7 )[1] == 5.,
      |                                                             ^

tests/basic/test-attribute.cpp:360:71: warning: [cppcoreguidelines-avoid-magic-numbers]

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

  360 |     geode::OpenGeodeBasicException::test( attribute->value( 7 )[1] == 5.,
      |                                                                       ^

tests/basic/test-attribute.cpp:361:70: warning: [cppcoreguidelines-avoid-magic-numbers]

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

  361 |         "Value [7,1] Should be equal to 5., not ", attribute->value( 7 )[1] );
      |                                                                      ^

tests/basic/test-attribute.cpp:362:61: warning: [cppcoreguidelines-avoid-magic-numbers]

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

  362 |     geode::OpenGeodeBasicException::test( attribute->value( 7 )[2] == 7.,
      |                                                             ^

tests/basic/test-attribute.cpp:362:71: warning: [cppcoreguidelines-avoid-magic-numbers]

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

  362 |     geode::OpenGeodeBasicException::test( attribute->value( 7 )[2] == 7.,
      |                                                                       ^

tests/basic/test-attribute.cpp:363:70: warning: [cppcoreguidelines-avoid-magic-numbers]

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

  363 |         "Value [7,2] Should be equal to 7., not ", attribute->value( 7 )[2] );
      |                                                                      ^

tests/basic/test-attribute.cpp:365:38: warning: [cppcoreguidelines-avoid-magic-numbers]
1. is a magic number; consider replacing it with a named constant
```
  365 |     array_attribute->set_value( 3, { 2., 5., 5. } );
      |                                      ^
```
tests/basic/test-attribute.cpp:365:42: warning: [cppcoreguidelines-avoid-magic-numbers]
1. is a magic number; consider replacing it with a named constant
```
  365 |     array_attribute->set_value( 3, { 2., 5., 5. } );
      |                                          ^
```
tests/basic/test-attribute.cpp:365:46: warning: [cppcoreguidelines-avoid-magic-numbers]
1. is a magic number; consider replacing it with a named constant
```
  365 |     array_attribute->set_value( 3, { 2., 5., 5. } );
      |                                              ^
```
tests/basic/test-attribute.cpp:367:37: warning: [cppcoreguidelines-avoid-magic-numbers]
1. is a magic number; consider replacing it with a named constant
```
  367 |         attribute->value( 3 )[0] == 2., "Should be equal to 2." );
      |                                     ^
```
tests/basic/test-attribute.cpp:369:37: warning: [cppcoreguidelines-avoid-magic-numbers]
1. is a magic number; consider replacing it with a named constant
```
  369 |         attribute->value( 3 )[1] == 5., "Should be equal to 5." );
      |                                     ^
```
tests/basic/test-attribute.cpp:371:37: warning: [cppcoreguidelines-avoid-magic-numbers]
1. is a magic number; consider replacing it with a named constant
```
  371 |         attribute->value( 3 )[2] == 5., "Should be equal to 5." );
      |                                     ^
```
tests/basic/test-attribute.cpp:374:6: warning: [misc-use-internal-linkage]

function 'test_bool_variable_attribute' can be made static or moved into an anonymous namespace to enforce internal linkage
```
  374 | void test_bool_variable_attribute(
      |      ^
      | static 
```

tests/basic/test-attribute.cpp:381:5: warning: [cppcoreguidelines-pro-type-member-init]

uninitialized record type: 'attribute_values'

  381 |     geode::AttributeValues< bool > attribute_values;
      |     ^                                              
      |                                                    {}

tests/basic/test-attribute.cpp:391:63: warning: [readability-simplify-boolean-expr]

redundant boolean literal supplied to boolean operator

  391 |         variable_attribute->default_values().default_value == false,
      |         ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^~~~~
      |         !variable_attribute->default_values().default_value

tests/basic/test-attribute.cpp:405:6: warning: [misc-use-internal-linkage]

function 'managers_have_same_attributes' can be made static or moved into an anonymous namespace to enforce internal linkage
```
  405 | bool managers_have_same_attributes( const geode::AttributeManager& manager,
      |      ^
      | static 
```
tests/basic/test-attribute.cpp:433:6: warning: [misc-use-internal-linkage]

function 'check_one_attribute_values' can be made static or moved into an anonymous namespace to enforce internal linkage
```
  433 | void check_one_attribute_values( geode::AttributeManager& manager,
      |      ^
      | static 
```

tests/basic/test-attribute.cpp:433:34: warning: [bugprone-easily-swappable-parameters]

2 adjacent parameters of 'check_one_attribute_values' of similar type ('geode::AttributeManager &') are easily swapped by mistake

  433 | void check_one_attribute_values( geode::AttributeManager& manager,
      |                                  ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  434 |     geode::AttributeManager& reloaded_manager,
      |     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/__w/OpenGeode/OpenGeode/tests/basic/test-attribute.cpp:433:59: note: the first parameter in the range is 'manager'
  433 | void check_one_attribute_values( geode::AttributeManager& manager,
      |                                                           ^~~~~~~
/__w/OpenGeode/OpenGeode/tests/basic/test-attribute.cpp:434:30: note: the last parameter in the range is 'reloaded_manager'
  434 |     geode::AttributeManager& reloaded_manager,
      |                              ^~~~~~~~~~~~~~~~

tests/basic/test-attribute.cpp:449:6: warning: [misc-use-internal-linkage]

function 'check_attribute_values' can be made static or moved into an anonymous namespace to enforce internal linkage
```
  449 | void check_attribute_values( geode::AttributeManager& manager,
      |      ^
      | static 
```
tests/basic/test-attribute.cpp:451:36: warning: [cppcoreguidelines-avoid-magic-numbers]

7 is a magic number; consider replacing it with a named constant
```
  451 |     const std::array< geode::uuid, 7 >& attribute_to_check )
      |                                    ^
```
tests/basic/test-attribute.cpp:464:55: warning: [cppcoreguidelines-avoid-magic-numbers]

5 is a magic number; consider replacing it with a named constant
```
  464 |         manager, reloaded_manager, attribute_to_check[5] );
      |                                                       ^
```
tests/basic/test-attribute.cpp:466:55: warning: [cppcoreguidelines-avoid-magic-numbers]

6 is a magic number; consider replacing it with a named constant
```
  466 |         manager, reloaded_manager, attribute_to_check[6] );
      |                                                       ^
```
tests/basic/test-attribute.cpp:469:6: warning: [misc-use-internal-linkage]

function 'test_serialize_manager' can be made static or moved into an anonymous namespace to enforce internal linkage
```
  469 | void test_serialize_manager( geode::AttributeManager& manager,
      |      ^
      | static 
```
tests/basic/test-attribute.cpp:470:36: warning: [cppcoreguidelines-avoid-magic-numbers]

7 is a magic number; consider replacing it with a named constant
```
  470 |     const std::array< geode::uuid, 7 >& attribute_to_check )
      |                                    ^
```
tests/basic/test-attribute.cpp:472:5: warning: [llvm-qualified-auto]

'const auto filename' can be declared as 'const auto *const filename'
```
  472 |     const auto filename = "manager.out";
      |     ^~~~~~~~~~
      |     const auto *const 
```
tests/basic/test-attribute.cpp:489:57: warning: [cppcoreguidelines-avoid-magic-numbers]

30 is a magic number; consider replacing it with a named constant
```
  489 |     geode::register_attribute_type< std::array< double, 30 >,
      |                                                         ^
```
tests/basic/test-attribute.cpp:518:6: warning: [misc-use-internal-linkage]

function 'test_attribute_types' can be made static or moved into an anonymous namespace to enforce internal linkage
```
  518 | void test_attribute_types( geode::AttributeManager& manager,
      |      ^
      | static 
```
tests/basic/test-attribute.cpp:531:6: warning: [misc-use-internal-linkage]

function 'test_attribute_names' can be made static or moved into an anonymous namespace to enforce internal linkage
```
  531 | void test_attribute_names( geode::AttributeManager& manager,
      |      ^
      | static 
```

tests/basic/test-attribute.cpp:535:9: warning: [bugprone-unchecked-optional-access]

unchecked access to optional value

  535 |         manager.find_attribute< geode::VariableAttribute, bool >(
      |         ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  536 |                    bool_variable_attribute_id )
      |                    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  537 |                 ->name()
      |                 ~~~~~~~~

tests/basic/test-attribute.cpp:543:6: warning: [misc-use-internal-linkage]

function 'test_number_of_attributes' can be made static or moved into an anonymous namespace to enforce internal linkage
```
  543 | void test_number_of_attributes(
      |      ^
      | static 
```
tests/basic/test-attribute.cpp:544:54: warning: [readability-identifier-length]

parameter name 'nb' is too short, expected at least 3 characters
```
  544 |     geode::AttributeManager& manager, geode::index_t nb )
      |                                                      ^
```
tests/basic/test-attribute.cpp:550:6: warning: [misc-use-internal-linkage]

function 'test_delete_attribute_elements' can be made static or moved into an anonymous namespace to enforce internal linkage
```
  550 | void test_delete_attribute_elements( geode::AttributeManager& manager )
      |      ^
      | static 
```
tests/basic/test-attribute.cpp:554:15: warning: [cppcoreguidelines-avoid-magic-numbers]

5 is a magic number; consider replacing it with a named constant
```
  554 |     to_delete[5] = true;
      |               ^
```
tests/basic/test-attribute.cpp:561:6: warning: [misc-use-internal-linkage]

function 'test_sparse_attribute_after_element_deletion' can be made static or moved into an anonymous namespace to enforce internal linkage
```
  561 | void test_sparse_attribute_after_element_deletion(
      |      ^
      | static 
```

tests/basic/test-attribute.cpp:566:75: warning: [cppcoreguidelines-avoid-magic-numbers]

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

  566 |     geode::OpenGeodeBasicException::test( sparse_attribute->value( 0 ) == 12,
      |                                                                           ^

tests/basic/test-attribute.cpp:570:68: warning: [cppcoreguidelines-avoid-magic-numbers]

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

  570 |     geode::OpenGeodeBasicException::test( sparse_attribute->value( 5 ) == 8.1,
      |                                                                    ^

Have any feedback or feature suggestions? Share it here.

fix(AttributeManager): remove import method taking span

dcf157e

BenPinet requested a review from panquez August 14, 2026 12:11

panquez approved these changes Aug 14, 2026

View reviewed changes

BenPinet added 2 commits August 14, 2026 15:14

Merge branch 'v18' into fix/remove_import_method_taking_span

dc44b49

Merge branch 'v18' into fix/remove_import_method_taking_span

6cb3943

Navigation Menu

Uh oh!

Uh oh!

fix(AttributeManager): remove import method taking span - #1322

fix(AttributeManager): remove import method taking span#1322
BenPinet wants to merge 3 commits into
v18from
fix/remove_import_method_taking_span

BenPinet commented Aug 14, 2026

Uh oh!

github-actions Bot commented Aug 14, 2026

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

2 participants

Uh oh!

Uh oh!

Conversation

BenPinet commented Aug 14, 2026

Uh oh!

github-actions Bot commented Aug 14, 2026

Cpp-Linter Report ⚠️

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

2 participants