Rename assign_* to set_*

include/tao/json/basic_value.hpp

@@ -389,27 +389,27 @@ namespace tao::json
       }
 
    public:
-      void assign_null() noexcept
+      void set_null() noexcept
       {
          m_variant = null;
       }
 
-      void assign_boolean( const bool b ) noexcept
+      void set_boolean( const bool b ) noexcept
       {
          m_variant = b;
       }
 
-      void assign_signed( const std::int64_t i ) noexcept
+      void set_signed( const std::int64_t i ) noexcept
       {
          m_variant = i;
       }
 
-      void assign_unsigned( const std::uint64_t u ) noexcept
+      void set_unsigned( const std::uint64_t u ) noexcept
       {
          m_variant = u;
       }
 
-      void assign_double( const double d ) noexcept
+      void set_double( const double d ) noexcept
       {
          m_variant = d;
       }
@@ -420,17 +420,17 @@ namespace tao::json
          m_variant.template emplace< std::string >( std::forward< Ts >( ts )... );
       }
 
-      void assign_string( const std::string& s )
+      void set_string( const std::string& s )
       {
          m_variant = s;
       }
 
-      void assign_string( std::string&& s ) noexcept
+      void set_string( std::string&& s ) noexcept
       {
          m_variant = std::move( s );
       }
 
-      void assign_string_view( const std::string_view sv ) noexcept
+      void set_string_view( const std::string_view sv ) noexcept
       {
          m_variant = sv;
       }
@@ -441,17 +441,17 @@ namespace tao::json
          m_variant.template emplace< binary >( std::forward< Ts >( ts )... );
       }
 
-      void assign_binary( const binary& x )
+      void set_binary( const binary& x )
       {
          m_variant = x;
       }
 
-      void assign_binary( binary&& x ) noexcept
+      void set_binary( binary&& x ) noexcept
       {
          m_variant = std::move( x );
       }
 
-      void assign_binary_view( const tao::binary_view xv ) noexcept
+      void set_binary_view( const tao::binary_view xv ) noexcept
       {
          m_variant = xv;
       }
@@ -462,12 +462,12 @@ namespace tao::json
          m_variant.template emplace< array_t >( std::forward< Ts >( ts )... );
       }
 
-      void assign_array( const array_t& a )
+      void set_array( const array_t& a )
       {
          m_variant = a;
       }
 
-      void assign_array( array_t&& a ) noexcept( std::is_nothrow_move_assignable_v< array_t > )
+      void set_array( array_t&& a ) noexcept( std::is_nothrow_move_assignable_v< array_t > )
       {
          m_variant = std::move( a );
       }
@@ -502,12 +502,12 @@ namespace tao::json
          m_variant.template emplace< object_t >( std::forward< Ts >( ts )... );
       }
 
-      void assign_object( const object_t& o )
+      void set_object( const object_t& o )
       {
          m_variant = o;
       }
 
-      void assign_object( object_t&& o ) noexcept( std::is_nothrow_move_assignable_v< object_t > )
+      void set_object( object_t&& o ) noexcept( std::is_nothrow_move_assignable_v< object_t > )
       {
          m_variant = std::move( o );
       }
@@ -540,14 +540,14 @@ namespace tao::json
          return prepare_object().emplace( t );
       }
 
-      void assign_value_ptr( const basic_value* p ) noexcept
+      void set_value_ptr( const basic_value* p ) noexcept
       {
          assert( p );
          m_variant = p;
       }
 
       template< typename T >
-      void assign_opaque_ptr( const T* data, const producer_t producer ) noexcept
+      void set_opaque_ptr( const T* data, const producer_t producer ) noexcept
       {
          assert( data );
          assert( producer );
@@ -558,9 +558,9 @@ namespace tao::json
       }
 
       template< typename T >
-      void assign_opaque_ptr( const T* data ) noexcept
+      void set_opaque_ptr( const T* data ) noexcept
       {
-         assign_opaque_ptr( data, &basic_value::produce_from_opaque_ptr< T > );
+         set_opaque_ptr( data, &basic_value::produce_from_opaque_ptr< T > );
       }
 
       template< typename T >

include/tao/json/contrib/reference.hpp

@@ -82,7 +82,7 @@ namespace tao::json
                         if( p == &v ) {
                            throw std::runtime_error( "JSON Reference: invalid self reference" );
                         }
-                        v.assign_value_ptr( p );
+                        v.set_value_ptr( p );
                         resolve_references( r, v );
                      }
                      else {

include/tao/json/events/to_value.hpp

@@ -27,27 +27,27 @@ namespace tao::json::events
 
       void null()
       {
-         value.assign_null();
+         value.set_null();
       }
 
       void boolean( const bool v )
       {
-         value.assign_boolean( v );
+         value.set_boolean( v );
       }
 
       void number( const std::int64_t v )
       {
-         value.assign_signed( v );
+         value.set_signed( v );
       }
 
       void number( const std::uint64_t v )
       {
-         value.assign_unsigned( v );
+         value.set_unsigned( v );
       }
 
       void number( const double v )
       {
-         value.assign_double( v );
+         value.set_double( v );
       }
 
       void string( const std::string_view v )

include/tao/json/internal/number_traits.hpp

@@ -58,7 +58,7 @@ namespace tao::json::internal
       template< template< typename... > class Traits >
       static void assign( basic_value< Traits >& v, const T i ) noexcept
       {
-         v.assign_signed( i );
+         v.set_signed( i );
       }
 
       template< template< typename... > class Traits >
@@ -129,7 +129,7 @@ namespace tao::json::internal
       template< template< typename... > class Traits >
       static void assign( basic_value< Traits >& v, const T i ) noexcept
       {
-         v.assign_unsigned( i );
+         v.set_unsigned( i );
       }
 
       template< template< typename... > class Traits >
@@ -206,7 +206,7 @@ namespace tao::json::internal
       template< template< typename... > class Traits >
       static void assign( basic_value< Traits >& v, const T f ) noexcept
       {
-         v.assign_double( f );
+         v.set_double( f );
       }
 
       template< template< typename... > class Traits >

include/tao/json/traits.hpp

@@ -73,7 +73,7 @@ namespace tao::json
       template< template< typename... > class Traits >
       static void assign( basic_value< Traits >& v, null_t /*unused*/ ) noexcept
       {
-         v.assign_null();
+         v.set_null();
       }
 
       template< template< typename... > class Traits, typename Consumer >
@@ -113,7 +113,7 @@ namespace tao::json
       template< template< typename... > class Traits >
       static void assign( basic_value< Traits >& v, const bool b ) noexcept
       {
-         v.assign_boolean( b );
+         v.set_boolean( b );
       }
 
       template< template< typename... > class, typename Producer >
@@ -356,13 +356,13 @@ namespace tao::json
       template< template< typename... > class Traits >
       static void assign( basic_value< Traits >& v, const std::string& s )
       {
-         v.assign_string( s );
+         v.set_string( s );
       }
 
       template< template< typename... > class Traits >
       static void assign( basic_value< Traits >& v, std::string&& s ) noexcept
       {
-         v.assign_string( std::move( s ) );
+         v.set_string( std::move( s ) );
       }
 
       template< template< typename... > class, typename Producer >
@@ -586,13 +586,13 @@ namespace tao::json
       template< template< typename... > class Traits >
       static void assign( basic_value< Traits >& v, const std::vector< std::byte >& x )
       {
-         v.assign_binary( x );
+         v.set_binary( x );
       }
 
       template< template< typename... > class Traits >
       static void assign( basic_value< Traits >& v, std::vector< std::byte >&& x ) noexcept
       {
-         v.assign_binary( std::move( x ) );
+         v.set_binary( std::move( x ) );
       }
 
       template< template< typename... > class, typename Producer >
@@ -758,12 +758,12 @@ namespace tao::json
    {
       static void assign( basic_value< Traits >& v, const std::vector< basic_value< Traits > >& a )
       {
-         v.assign_array( a );
+         v.set_array( a );
       }
 
       static void assign( basic_value< Traits >& v, std::vector< basic_value< Traits > >&& a ) noexcept
       {
-         v.assign_array( std::move( a ) );
+         v.set_array( std::move( a ) );
       }
 
       template< template< typename... > class, typename Consumer >
@@ -794,12 +794,12 @@ namespace tao::json
    {
       static void assign( basic_value< Traits >& v, const std::map< std::string, basic_value< Traits >, std::less<> >& o )
       {
-         v.assign_object( std::move( o ) );
+         v.set_object( std::move( o ) );
       }
 
       static void assign( basic_value< Traits >& v, std::map< std::string, basic_value< Traits >, std::less<> >&& o ) noexcept
       {
-         v.assign_object( std::move( o ) );
+         v.set_object( std::move( o ) );
       }
 
       template< template< typename... > class, typename Consumer >
@@ -832,7 +832,7 @@ namespace tao::json
    {
       static void assign( basic_value< Traits >& v, const basic_value< Traits >* p ) noexcept
       {
-         v.assign_value_ptr( p );
+         v.set_value_ptr( p );
       }
 
       template< template< typename... > class TraitsLL >
@@ -891,7 +891,7 @@ namespace tao::json
             v.assign( *o );
          }
          else {
-            v.assign_null();
+            v.set_null();
          }
       }
 

src/test/json/opaque_pointer.cpp

@@ -155,7 +155,7 @@ namespace tao::json
    {
       static void assign( value& v, const employee* e )
       {
-         v.assign_opaque_ptr( e );
+         v.set_opaque_ptr( e );
       }
    };
 

src/test/json/string_view.cpp

@@ -53,7 +53,7 @@ namespace tao::json
 
       // storing a string_view is possible
       value v;
-      v.assign_string_view( sv );
+      v.set_string_view( sv );
 
       TEST_ASSERT( v.type() == type::STRING_VIEW );