Peerplays_Blockchain/peerplays-fc
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

FC Updates from BitShares and myself #21

Closed
nathanielhourt wants to merge 687 commits from dapp-support into latest-fc
pull from: dapp-support
merge into: Peerplays_Blockchain:latest-fc
Conversation 4 Commits 687 Files changed 314 +29 -34
8 changed files with 29 additions and 34 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files
Showing only changes of commit a8337ecc42 - Show all commits

2
include/fc/bloom_filter.hpp
View file

@ -31,7 +31,7 @@
namespace fc { namespace fc {
static const std::size_t bits_per_char = 0x08; // 8 bits in 1 char(unsigned) static constexpr std::size_t bits_per_char = 0x08; // 8 bits in 1 char(unsigned)
static const unsigned char bit_mask[bits_per_char] = { static const unsigned char bit_mask[bits_per_char] = {
0x01, //00000001 0x01, //00000001
0x02, //00000010 0x02, //00000010

2
include/fc/crypto/ripemd160.hpp
View file

@ -18,7 +18,7 @@ class ripemd160
explicit operator string()const; explicit operator string()const;
char* data()const; char* data()const;
size_t data_size()const { return 160/8; } constexpr size_t data_size()const { return 160/8; }
static ripemd160 hash( const fc::sha512& h ); static ripemd160 hash( const fc::sha512& h );
static ripemd160 hash( const fc::sha256& h ); static ripemd160 hash( const fc::sha256& h );

2
include/fc/crypto/sha1.hpp
View file

@ -17,7 +17,7 @@ class sha1
operator std::string()const; operator std::string()const;
char* data()const; char* data()const;
size_t data_size()const { return 20; } constexpr size_t data_size()const { return 20; }
static sha1 hash( const char* d, uint32_t dlen ); static sha1 hash( const char* d, uint32_t dlen );
static sha1 hash( const std::string& ); static sha1 hash( const std::string& );

2
include/fc/crypto/sha224.hpp
View file

@ -16,7 +16,7 @@ class sha224
operator string()const; operator string()const;
char* data()const; char* data()const;
size_t data_size()const { return 224 / 8; } constexpr size_t data_size()const { return 224 / 8; }
static sha224 hash( const char* d, uint32_t dlen ); static sha224 hash( const char* d, uint32_t dlen );
static sha224 hash( const string& ); static sha224 hash( const string& );

2
include/fc/crypto/sha256.hpp
View file

@ -18,7 +18,7 @@ class sha256
operator string()const; operator string()const;
char* data()const; char* data()const;
size_t data_size()const { return 256 / 8; } constexpr size_t data_size()const { return 256 / 8; }
static sha256 hash( const char* d, uint32_t dlen ); static sha256 hash( const char* d, uint32_t dlen );
static sha256 hash( const string& ); static sha256 hash( const string& );

2
include/fc/crypto/sha512.hpp
View file

@ -16,7 +16,7 @@ class sha512
operator std::string()const; operator std::string()const;
char* data()const; char* data()const;
size_t data_size()const { return 512 / 8; } constexpr size_t data_size()const { return 512 / 8; }
static sha512 hash( const char* d, uint32_t dlen ); static sha512 hash( const char* d, uint32_t dlen );
static sha512 hash( const std::string& ); static sha512 hash( const std::string& );

6
include/fc/safe.hpp
View file

@ -26,11 +26,11 @@ namespace fc {
safe(){} safe(){}
safe( const safe& o ):value(o.value){} safe( const safe& o ):value(o.value){}
static safe min() static constexpr safe min()
{ {
return std::numeric_limits<T>::min(); return std::numeric_limits<T>::min();
} }
static safe max() static constexpr safe max()
{ {
return std::numeric_limits<T>::max(); return std::numeric_limits<T>::max();
} }
@ -91,7 +91,7 @@ namespace fc {
safe operator - ()const safe operator - ()const
{ {
if( value == std::numeric_limits<T>::min() ) FC_CAPTURE_AND_THROW( overflow_exception, (*this) ); if( value == min() ) FC_CAPTURE_AND_THROW( overflow_exception, (*this) );
return safe( -value ); return safe( -value );
} }

45
include/fc/static_variant.hpp
View file

@ -141,58 +141,53 @@ struct storage_ops<N> {
template<typename X> template<typename X>
struct position<X> { struct position<X> {
static const int pos = -1; static constexpr int pos = -1;
}; };
template<typename X, typename... Ts> template<typename X, typename... Ts>
struct position<X, X, Ts...> { struct position<X, X, Ts...> {
static const int pos = 0; static constexpr int pos = 0;
}; };
template<typename X, typename T, typename... Ts> template<typename X, typename T, typename... Ts>
struct position<X, T, Ts...> { struct position<X, T, Ts...> {
static const int pos = position<X, Ts...>::pos != -1 ? position<X, Ts...>::pos + 1 : -1; static constexpr int pos = position<X, Ts...>::pos != -1 ? position<X, Ts...>::pos + 1 : -1;
}; };
template<typename T, typename... Ts> template<typename T, typename... Ts>
struct type_info<T&, Ts...> { struct type_info<T&, Ts...> {
static const bool no_reference_types = false; static constexpr bool no_reference_types = false;
static const bool no_duplicates = position<T, Ts...>::pos == -1 && type_info<Ts...>::no_duplicates; static constexpr bool no_duplicates = position<T, Ts...>::pos == -1 && type_info<Ts...>::no_duplicates;
static const size_t size = type_info<Ts...>::size > sizeof(T&) ? type_info<Ts...>::size : sizeof(T&); static constexpr size_t size = type_info<Ts...>::size > sizeof(T&) ? type_info<Ts...>::size : sizeof(T&);
static const size_t count = 1 + type_info<Ts...>::count; static constexpr size_t count = 1 + type_info<Ts...>::count;
}; };
template<typename T, typename... Ts> template<typename T, typename... Ts>
struct type_info<T, Ts...> { struct type_info<T, Ts...> {
static const bool no_reference_types = type_info<Ts...>::no_reference_types; static constexpr bool no_reference_types = type_info<Ts...>::no_reference_types;
static const bool no_duplicates = position<T, Ts...>::pos == -1 && type_info<Ts...>::no_duplicates; static constexpr bool no_duplicates = position<T, Ts...>::pos == -1 && type_info<Ts...>::no_duplicates;
static const size_t size = type_info<Ts...>::size > sizeof(T) ? type_info<Ts...>::size : sizeof(T&); static constexpr size_t size = type_info<Ts...>::size > sizeof(T) ? type_info<Ts...>::size : sizeof(T&);
static const size_t count = 1 + type_info<Ts...>::count; static constexpr size_t count = 1 + type_info<Ts...>::count;
}; };
template<> template<>
struct type_info<> { struct type_info<> {
static const bool no_reference_types = true; static constexpr bool no_reference_types = true;
static const bool no_duplicates = true; static constexpr bool no_duplicates = true;
static const size_t count = 0; static constexpr size_t count = 0;
static const size_t size = 0; static constexpr size_t size = 0;
}; };
template<typename TTag> template<typename TTag>
size_t size( TTag ) constexpr size_t size( TTag )
{ {
return 0; return 0;
} }
template<typename TTag, typename A, typename...Ts> template<typename TTag, typename A, typename...Ts>
size_t size( TTag tag ) constexpr size_t size( TTag tag )
{ {
if (tag <= 0) return tag <= 0 ? sizeof(A) : size<TTag, Ts...>( --tag );
{
return sizeof(A);
}
return size<TTag, Ts...>( --tag );
} }
@ -304,7 +299,7 @@ public:
template<typename X, typename = type_in_typelist<X>> template<typename X, typename = type_in_typelist<X>>
struct tag struct tag
{ {
static const int value = impl::position<X, Types...>::pos; static constexpr int value = impl::position<X, Types...>::pos;
}; };
static_variant() static_variant()
@ -434,7 +429,7 @@ public:
return wrappers[tag]( v, data ); return wrappers[tag]( v, data );
} }
static int count() { return impl::type_info<Types...>::count; } static constexpr int count() { return impl::type_info<Types...>::count; }
void set_which( tag_type w ) { void set_which( tag_type w ) {
FC_ASSERT( w >= 0 ); FC_ASSERT( w >= 0 );
FC_ASSERT( w < count() ); FC_ASSERT( w < count() );