Replaced fc::array with std::array

libraries/chain/include/graphene/chain/protocol/address.hpp

@@ -27,8 +27,8 @@
 #include <graphene/chain/pts_address.hpp>
 #include <graphene/chain/protocol/types.hpp>
 
+#include <fc/crypto/elliptic.hpp>
 #include <fc/crypto/ripemd160.hpp>
-#include <fc/reflect/typename.hpp>
 
 namespace graphene { namespace chain {
 

libraries/chain/include/graphene/chain/pts_address.hpp

@@ -23,10 +23,13 @@
  */
 #pragma once
 
-#include <fc/array.hpp>
+#include <array>
+#include <cstring>
+#include <string>
+
 #include <fc/io/datastream.hpp>
 #include <fc/io/raw_fwd.hpp>
-#include <string>
+#include <fc/variant.hpp>
 
 namespace fc { namespace ecc { class public_key; } }
 
@@ -46,7 +49,7 @@ namespace graphene { namespace chain {
 
        operator std::string()const; ///< converts to base58 + checksum
 
-       fc::array<char,25> addr; ///< binary representation of address
+       std::array<char,25> addr; ///< binary representation of address
    };
 
    inline bool operator == ( const pts_address& a, const pts_address& b ) { return a.addr == b.addr; }
@@ -64,7 +67,7 @@ namespace std
          size_t operator()(const graphene::chain::pts_address &a) const 
          {
             size_t s;
-            memcpy( (char*)&s, &a.addr.data[sizeof(a)-sizeof(s)], sizeof(s) );
+            std::memcpy( (char*)&s, a.addr.data() + a.addr.size() - sizeof(s), sizeof(s) );
             return s;
          }
    };

libraries/chain/protocol/address.cpp

@@ -71,7 +71,7 @@ namespace graphene {
    address::address( const fc::ecc::public_key& pub )
    {
        auto dat = pub.serialize();
-       addr = fc::ripemd160::hash( fc::sha512::hash( dat.data, sizeof( dat ) ) );
+       addr = fc::ripemd160::hash( fc::sha512::hash( (char*) dat.data(), dat.size() ) );
    }
 
    address::address( const pts_address& ptsaddr )
@@ -81,21 +81,22 @@ namespace graphene {
 
    address::address( const fc::ecc::public_key_data& pub )
    {
-       addr = fc::ripemd160::hash( fc::sha512::hash( pub.data, sizeof( pub ) ) );
+       addr = fc::ripemd160::hash( fc::sha512::hash( (char*) pub.data(), pub.size() ) );
    }
 
    address::address( const graphene::chain::public_key_type& pub )
    {
-       addr = fc::ripemd160::hash( fc::sha512::hash( pub.key_data.data, sizeof( pub.key_data ) ) );
+       addr = fc::ripemd160::hash( fc::sha512::hash( (char*) pub.key_data.data(), pub.key_data.size() ) );
    }
 
    address::operator std::string()const
    {
-        fc::array<char,24> bin_addr;
+        std::array<char,24> bin_addr;
-        memcpy( (char*)&bin_addr, (char*)&addr, sizeof( addr ) );
+        static_assert( bin_addr.size() >= sizeof(addr) + 4 );
-        auto checksum = fc::ripemd160::hash( (char*)&addr, sizeof( addr ) );
+        memcpy( bin_addr.data(), addr.data(), sizeof(addr) );
-        memcpy( ((char*)&bin_addr)+20, (char*)&checksum._hash[0], 4 );
+        auto checksum = fc::ripemd160::hash( addr.data(), sizeof(addr) );
-        return GRAPHENE_ADDRESS_PREFIX + fc::to_base58( bin_addr.data, sizeof( bin_addr ) );
+        memcpy( bin_addr.data() + 20, (char*)&checksum._hash[0], 4 );
+        return GRAPHENE_ADDRESS_PREFIX + fc::to_base58( bin_addr.data(), bin_addr.size() );
    }
 
 } } // namespace graphene::chain

libraries/chain/pts_address.cpp

@@ -34,14 +34,14 @@ namespace graphene { namespace chain {
 
    pts_address::pts_address()
    {
-      memset( addr.data, 0, sizeof(addr.data) );
+      memset( addr.data(), 0, addr.size() );
    }
 
    pts_address::pts_address( const std::string& base58str )
    {
       std::vector<char> v = fc::from_base58( fc::string(base58str) );
       if( v.size() )
-         memcpy( addr.data, v.data(), std::min<size_t>( v.size(), sizeof(addr) ) );
+         memcpy( addr.data(), v.data(), std::min<size_t>( v.size(), addr.size() ) );
 
       if( !is_valid() )
       {
@@ -55,19 +55,19 @@ namespace graphene { namespace chain {
        if( compressed )
        {
            auto dat = pub.serialize();
-           sha2     = fc::sha256::hash(dat.data, sizeof(dat) );
+           sha2     = fc::sha256::hash((char*) dat.data(), dat.size() );
        }
        else
        {
            auto dat = pub.serialize_ecc_point();
-           sha2     = fc::sha256::hash(dat.data, sizeof(dat) );
+           sha2     = fc::sha256::hash((char*) dat.data(), dat.size() );
        }
        auto rep      = fc::ripemd160::hash((char*)&sha2,sizeof(sha2));
-       addr.data[0]  = version;
+       addr[0]  = version;
-       memcpy( addr.data+1, (char*)&rep, sizeof(rep) );
+       memcpy( addr.data() + 1, (char*)&rep, sizeof(rep) );
-       auto check    = fc::sha256::hash( addr.data, sizeof(rep)+1 );
+       auto check    = fc::sha256::hash( addr.data(), sizeof(rep)+1 );
        check = fc::sha256::hash(check);
-       memcpy( addr.data+1+sizeof(rep), (char*)&check, 4 );
+       memcpy( addr.data() + 1 + sizeof(rep), (char*)&check, 4 );
    }
 
    /**
@@ -76,14 +76,14 @@ namespace graphene { namespace chain {
     */
    bool pts_address::is_valid()const
    {
-       auto check    = fc::sha256::hash( addr.data, sizeof(fc::ripemd160)+1 );
+       auto check    = fc::sha256::hash( addr.data(), sizeof(fc::ripemd160)+1 );
        check = fc::sha256::hash(check);
-       return memcmp( addr.data+1+sizeof(fc::ripemd160), (char*)&check, 4 ) == 0;
+       return memcmp( addr.data() + 1 + sizeof(fc::ripemd160), (char*)&check, 4 ) == 0;
    }
 
    pts_address::operator std::string()const
    {
-        return fc::to_base58( addr.data, sizeof(addr) );
+        return fc::to_base58( addr.data(), addr.size() );
    }
 
 } } // namespace graphene

libraries/net/include/graphene/net/stcp_socket.hpp

@@ -26,6 +26,8 @@
 #include <fc/crypto/aes.hpp>
 #include <fc/crypto/elliptic.hpp>
 
+#include <array>
+
 namespace graphene { namespace net {
 
 /**

libraries/net/node.cpp

@@ -827,7 +827,7 @@ namespace graphene { namespace net { namespace detail {
       _maximum_blocks_per_peer_during_syncing(GRAPHENE_NET_MAX_BLOCKS_PER_PEER_DURING_SYNCING)
     {
       _rate_limiter.set_actual_rate_time_constant(fc::seconds(2));
-      fc::rand_bytes(&_node_id.data[0], (int)_node_id.size());
+      fc::rand_bytes((char*) _node_id.data(), (int)_node_id.size());
     }
 
     node_impl::~node_impl()

programs/js_operation_serializer/main.cpp

@@ -113,12 +113,13 @@ bool register_serializer( const string& name, std::function<void()> sr )
 template<typename T> struct js_name { static std::string name(){ return  remove_namespace(fc::get_typename<T>::name()); }; };
 
 template<typename T, size_t N>
-struct js_name<fc::array<T,N>>
+struct js_name<std::array<T,N>>
 {
-   static std::string name(){ return  "fixed_array "+ fc::to_string(N) + ", "  + remove_namespace(fc::get_typename<T>::name()); };
+   static std::string name(){ return  "fixed_array "+ fc::to_string(N) + ", " 
+                                      + remove_namespace(fc::get_typename<T>::name()); };
 };
-template<size_t N>   struct js_name<fc::array<char,N>>    { static std::string name(){ return  "bytes "+ fc::to_string(N); }; };
+template<size_t N>   struct js_name<std::array<char,N>>   { static std::string name(){ return  "bytes "+ fc::to_string(N); }; };
-template<size_t N>   struct js_name<fc::array<uint8_t,N>> { static std::string name(){ return  "bytes "+ fc::to_string(N); }; };
+template<size_t N>   struct js_name<std::array<uint8_t,N>>{ static std::string name(){ return  "bytes "+ fc::to_string(N); }; };
 template<typename T> struct js_name< fc::optional<T> >    { static std::string name(){ return "optional " + js_name<T>::name(); } };
 template<>           struct js_name< object_id_type >     { static std::string name(){ return "object_id_type"; } };
 template<typename T> struct js_name< fc::flat_set<T> >    { static std::string name(){ return "set " + js_name<T>::name(); } };
@@ -235,7 +236,7 @@ struct serializer<T,false>
 };
 
 template<typename T, size_t N>
-struct serializer<fc::array<T,N>,false>
+struct serializer<std::array<T,N>,false>
 {
    static void init() { serializer<T>::init(); }
    static void generate() {}