Peerplays_Blockchain/peerplays_migrated
1
0
Fork 0
Code Issues 35 Pull requests 4 Projects Releases 20 Packages Wiki Activity Actions

Replaced fc::array with std::array

Browse source
This commit is contained in:
Peter Conrad 2019-05-29 11:22:42 +02:00 committed by Nathan Hourt
parent ced4380664
commit 0569efc068
No known key found for this signature in database
GPG key ID: B4344309A110851E
7 changed files with 37 additions and 30 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
libraries/chain/include/graphene/chain/protocol/address.hpp
View file

@ -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 {

11
libraries/chain/include/graphene/chain/pts_address.hpp
View file

@ -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;
}
};

17
libraries/chain/protocol/address.cpp
View file

@ -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;
memcpy( (char*)&bin_addr, (char*)&addr, sizeof( addr ) );
auto checksum = fc::ripemd160::hash( (char*)&addr, sizeof( addr ) );
memcpy( ((char*)&bin_addr)+20, (char*)&checksum._hash[0], 4 );
return GRAPHENE_ADDRESS_PREFIX + fc::to_base58( bin_addr.data, sizeof( bin_addr ) );
std::array<char,24> bin_addr;
static_assert( bin_addr.size() >= sizeof(addr) + 4 );
memcpy( bin_addr.data(), addr.data(), sizeof(addr) );
auto checksum = fc::ripemd160::hash( addr.data(), sizeof(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

22
libraries/chain/pts_address.cpp
View file

@ -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;
memcpy( addr.data+1, (char*)&rep, sizeof(rep) );
auto check = fc::sha256::hash( addr.data, sizeof(rep)+1 );
addr[0] = version;
memcpy( addr.data() + 1, (char*)&rep, sizeof(rep) );
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

2
libraries/net/include/graphene/net/stcp_socket.hpp
View file

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

2
libraries/net/node.cpp
View file

@ -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()

11
programs/js_operation_serializer/main.cpp
View file

@ -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<fc::array<uint8_t,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<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() {}