diff --git a/CMakeLists.txt b/CMakeLists.txt index ebf8d16..fbf1ca0 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -233,12 +233,9 @@ set( fc_sources src/io/sstream.cpp src/io/json.cpp src/io/varint.cpp - src/io/console.cpp src/filesystem.cpp src/interprocess/signals.cpp src/interprocess/file_mapping.cpp - src/interprocess/mmap_struct.cpp - src/interprocess/file_mutex.cpp src/rpc/cli.cpp src/rpc/http_api.cpp src/rpc/json_connection.cpp diff --git a/fc.natvis b/fc.natvis index 7188bfa..81d74d6 100644 --- a/fc.natvis +++ b/fc.natvis @@ -31,12 +31,6 @@ - - {my} - - my - - invalid @@ -54,4 +48,4 @@ - \ No newline at end of file + diff --git a/include/fc/actor.hpp b/include/fc/actor.hpp deleted file mode 100644 index 920d742..0000000 --- a/include/fc/actor.hpp +++ /dev/null @@ -1,65 +0,0 @@ -#pragma once -#include -#include - -namespace fc { - - namespace detail { - struct actor_member { - #if 1 // BOOST_NO_VARIADIC_TEMPLATES - #define RPC_MEMBER_FUNCTOR(z,n,IS_CONST) \ - template \ - static std::function( BOOST_PP_ENUM_PARAMS(n,A) ) > \ - functor( P p, R (C::*mem_func)(BOOST_PP_ENUM_PARAMS(n,A)) IS_CONST, fc::thread* c = 0) { \ - return [=](BOOST_PP_ENUM_BINARY_PARAMS(n,A,a))->fc::future{ \ - return c->async( [=](){ return (p->*mem_func)(BOOST_PP_ENUM_PARAMS(n,a)); } ); }; \ - } - BOOST_PP_REPEAT( 8, RPC_MEMBER_FUNCTOR, const ) - BOOST_PP_REPEAT( 8, RPC_MEMBER_FUNCTOR, BOOST_PP_EMPTY() ) - #undef RPC_MEMBER_FUNCTOR - - #else // g++ has a bug that prevents lambdas and varidic templates from working together (G++ Bug 41933) - - template - static std::function(Args...)> functor( P&& p, R (C::*mem_func)(Args...), fc::thread* c ) { - return [=](Args... args)->fc::future{ c->async( [=]()->R { return p->*mem_func( fc::forward(args)... ); } ) }; - } - template - static std::function(Args...)> functor( P&& p, R (C::*mem_func)(Args...)const, fc::thread* c ){ - return [=](Args... args)->fc::future{ c->async( [=]()->R { return p->*mem_func( fc::forward(args)... ); } ) }; - } - #endif - }; - - template - struct actor_vtable_visitor { - template - actor_vtable_visitor( fc::thread* t, U&& u ):_thread(t),_this( fc::forward(u) ){} - - template - void operator()( const char* name, Function& memb, MemberPtr m )const { - memb = actor_member::functor( _this, m, _thread ); - } - fc::thread* _thread; - ThisPtr _this; - }; - } - - /** - * Posts all method calls to another thread and - * returns a future. - */ - template - class actor : public api { - public: - actor(){} - - template - actor( InterfaceType* p, fc::thread* t = &fc::thread::current() ) - { - this->_vtable.reset(new detail::vtable() ); - this->_vtable->template visit( detail::actor_vtable_visitor(t, p) ); - } - }; - -} // namespace fc diff --git a/include/fc/aligned.hpp b/include/fc/aligned.hpp deleted file mode 100644 index b107ed1..0000000 --- a/include/fc/aligned.hpp +++ /dev/null @@ -1,14 +0,0 @@ -#pragma once -namespace fc { - - template - struct aligned { - union { - T _align; - char _data[S]; - } _store; - operator char*() { return _store._data; } - operator const char*()const { return _store._data; } - }; - -} diff --git a/include/fc/any.hpp b/include/fc/any.hpp deleted file mode 100644 index 022d29e..0000000 --- a/include/fc/any.hpp +++ /dev/null @@ -1,7 +0,0 @@ -#pragma once -#include - -namespace fc { - // TODO: define this without using boost - typedef boost::any any; -} diff --git a/include/fc/api.hpp b/include/fc/api.hpp index 06414b1..3f68750 100644 --- a/include/fc/api.hpp +++ b/include/fc/api.hpp @@ -1,7 +1,7 @@ #pragma once #include -#include #include +#include #include // ms visual c++ (as of 2013) doesn't accept the standard syntax for calling a @@ -75,7 +75,7 @@ namespace fc { api( const T& p ) :_vtable( std::make_shared() ) { - _data = std::make_shared(p); + _data = std::make_shared(p); T& ptr = boost::any_cast(*_data); auto& pointed_at = *ptr; typedef typename std::remove_reference::type source_vtable_type; @@ -95,7 +95,7 @@ namespace fc { protected: std::shared_ptr _vtable; - std::shared_ptr _data; + std::shared_ptr _data; }; } // namespace fc diff --git a/include/fc/array.hpp b/include/fc/array.hpp index 541cd69..687b175 100644 --- a/include/fc/array.hpp +++ b/include/fc/array.hpp @@ -112,7 +112,7 @@ namespace fc { std::vector ve = v.as< std::vector >( 1 ); if( ve.size() ) { - memcpy(&bi, ve.data(), fc::min(ve.size(),sizeof(bi)) ); + memcpy(&bi, ve.data(), std::min(ve.size(),sizeof(bi)) ); } else memset( &bi, char(0), sizeof(bi) ); diff --git a/include/fc/asio.hpp b/include/fc/asio.hpp index 3d11a38..06ba2f8 100644 --- a/include/fc/asio.hpp +++ b/include/fc/asio.hpp @@ -282,7 +282,7 @@ namespace asio { { public: istream( std::shared_ptr str ) - :_stream( fc::move(str) ){} + :_stream( std::move(str) ){} virtual size_t readsome( char* buf, size_t len ) { @@ -302,7 +302,7 @@ namespace asio { { public: ostream( std::shared_ptr str ) - :_stream( fc::move(str) ){} + :_stream( std::move(str) ){} virtual size_t writesome( const char* buf, size_t len ) { diff --git a/include/fc/compress/zlib.hpp b/include/fc/compress/zlib.hpp index 10a3a0e..cd08ccf 100644 --- a/include/fc/compress/zlib.hpp +++ b/include/fc/compress/zlib.hpp @@ -1,10 +1,10 @@ #pragma once -#include +#include namespace fc { - string zlib_compress(const string& in); +std::string zlib_compress(const std::string& in); } // namespace fc diff --git a/include/fc/container/deque_fwd.hpp b/include/fc/container/deque_fwd.hpp deleted file mode 100644 index 71df18d..0000000 --- a/include/fc/container/deque_fwd.hpp +++ /dev/null @@ -1,14 +0,0 @@ -#pragma once - -#include -#include - -namespace fc { - - namespace raw { - template - void pack( Stream& s, const std::deque& value, uint32_t _max_depth=FC_PACK_MAX_DEPTH ); - template - void unpack( Stream& s, std::deque& value, uint32_t _max_depth=FC_PACK_MAX_DEPTH ); - } -} // namespace fc diff --git a/include/fc/crypto/base36.hpp b/include/fc/crypto/base36.hpp index aeb9c35..1cd158e 100644 --- a/include/fc/crypto/base36.hpp +++ b/include/fc/crypto/base36.hpp @@ -1,10 +1,9 @@ #pragma once -#include -#include +#include namespace fc { - std::vector from_base36( const fc::string& b36 ); - fc::string to_base36( const std::vector& vec ); - fc::string to_base36( const char* data, size_t len ); + std::vector from_base36( const std::string& b36 ); + std::string to_base36( const std::vector& vec ); + std::string to_base36( const char* data, size_t len ); } diff --git a/include/fc/crypto/base58.hpp b/include/fc/crypto/base58.hpp index 2f4fb38..17d52ea 100644 --- a/include/fc/crypto/base58.hpp +++ b/include/fc/crypto/base58.hpp @@ -1,5 +1,5 @@ #pragma once -#include +#include #include namespace fc { diff --git a/include/fc/crypto/bigint.hpp b/include/fc/crypto/bigint.hpp index 58703a1..1fdee13 100644 --- a/include/fc/crypto/bigint.hpp +++ b/include/fc/crypto/bigint.hpp @@ -1,7 +1,7 @@ #pragma once #include -#include -#include +#include +#include struct bignum_st; typedef bignum_st BIGNUM; @@ -55,7 +55,7 @@ namespace fc { bigint operator--(int); bigint& operator--(); - operator fc::string()const; + operator std::string()const; // returns bignum as bigendian bytes operator std::vector()const; diff --git a/include/fc/crypto/elliptic.hpp b/include/fc/crypto/elliptic.hpp index 3bc16b7..7ca2ec6 100644 --- a/include/fc/crypto/elliptic.hpp +++ b/include/fc/crypto/elliptic.hpp @@ -153,9 +153,9 @@ namespace fc { extended_key_data serialize_extended() const; static extended_public_key deserialize( const extended_key_data& data ); - fc::string str() const; - fc::string to_base58() const { return str(); } - static extended_public_key from_base58( const fc::string& base58 ); + std::string str() const; + std::string to_base58() const { return str(); } + static extended_public_key from_base58( const std::string& base58 ); private: sha256 c; @@ -177,10 +177,10 @@ namespace fc { extended_key_data serialize_extended() const; static extended_private_key deserialize( const extended_key_data& data ); - fc::string str() const; - fc::string to_base58() const { return str(); } - static extended_private_key from_base58( const fc::string& base58 ); - static extended_private_key generate_master( const fc::string& seed ); + std::string str() const; + std::string to_base58() const { return str(); } + static extended_private_key from_base58( const std::string& base58 ); + static extended_private_key generate_master( const std::string& seed ); static extended_private_key generate_master( const char* seed, uint32_t seed_len ); private: diff --git a/include/fc/crypto/hex.hpp b/include/fc/crypto/hex.hpp index 201f167..fd60d84 100644 --- a/include/fc/crypto/hex.hpp +++ b/include/fc/crypto/hex.hpp @@ -1,15 +1,15 @@ #pragma once -#include -#include +#include +#include #include namespace fc { uint8_t from_hex( char c ); - fc::string to_hex( const char* d, uint32_t s ); + std::string to_hex( const char* d, uint32_t s ); std::string to_hex( const std::vector& data ); /** * @return the number of bytes decoded */ - size_t from_hex( const fc::string& hex_str, char* out_data, size_t out_data_len ); + size_t from_hex( const std::string& hex_str, char* out_data, size_t out_data_len ); } diff --git a/include/fc/crypto/sha1.hpp b/include/fc/crypto/sha1.hpp index 01c6ca8..46b76e4 100644 --- a/include/fc/crypto/sha1.hpp +++ b/include/fc/crypto/sha1.hpp @@ -1,8 +1,8 @@ #pragma once #include -#include #include +#include namespace fc{ @@ -10,16 +10,16 @@ class sha1 { public: sha1(); - explicit sha1( const string& hex_str ); + explicit sha1( const std::string& hex_str ); - string str()const; - operator string()const; + std::string str()const; + operator std::string()const; char* data()const; size_t data_size()const { return 20; } static sha1 hash( const char* d, uint32_t dlen ); - static sha1 hash( const string& ); + static sha1 hash( const std::string& ); template static sha1 hash( const T& t ) diff --git a/include/fc/crypto/sha224.hpp b/include/fc/crypto/sha224.hpp index 20d484f..97a36b8 100644 --- a/include/fc/crypto/sha224.hpp +++ b/include/fc/crypto/sha224.hpp @@ -2,7 +2,6 @@ #include #include #include -#include namespace fc { diff --git a/include/fc/crypto/sha256.hpp b/include/fc/crypto/sha256.hpp index 33a2bfc..bdc6737 100644 --- a/include/fc/crypto/sha256.hpp +++ b/include/fc/crypto/sha256.hpp @@ -1,6 +1,5 @@ #pragma once #include -#include #include #include diff --git a/include/fc/crypto/sha512.hpp b/include/fc/crypto/sha512.hpp index a6c4a36..9751a56 100644 --- a/include/fc/crypto/sha512.hpp +++ b/include/fc/crypto/sha512.hpp @@ -1,6 +1,5 @@ #pragma once #include -#include namespace fc { diff --git a/include/fc/exception/exception.hpp b/include/fc/exception/exception.hpp index ec100f4..b9b6d8e 100644 --- a/include/fc/exception/exception.hpp +++ b/include/fc/exception/exception.hpp @@ -240,9 +240,9 @@ namespace fc TYPE( const std::string& what_value, const fc::log_messages& m ) \ :BASE( m, CODE, BOOST_PP_STRINGIZE(TYPE), what_value ){} \ TYPE( fc::log_message&& m ) \ - :BASE( fc::move(m), CODE, BOOST_PP_STRINGIZE(TYPE), WHAT ){}\ + :BASE( std::move(m), CODE, BOOST_PP_STRINGIZE(TYPE), WHAT ){}\ TYPE( fc::log_messages msgs ) \ - :BASE( fc::move( msgs ), CODE, BOOST_PP_STRINGIZE(TYPE), WHAT ) {} \ + :BASE( std::move( msgs ), CODE, BOOST_PP_STRINGIZE(TYPE), WHAT ) {} \ TYPE( const TYPE& c ) \ :BASE(c){} \ TYPE( const BASE& c ) \ diff --git a/include/fc/filesystem.hpp b/include/fc/filesystem.hpp index 38fb74a..bd1aa5d 100644 --- a/include/fc/filesystem.hpp +++ b/include/fc/filesystem.hpp @@ -2,7 +2,6 @@ #include #include -#include #include #include #include @@ -228,37 +227,5 @@ namespace fc { temp_directory(const fc::path& tempFolder = fc::temp_directory_path()); }; - -#if !defined(__APPLE__) - // this code is known to work on linux and windows. It may work correctly on mac, - // or it may need slight tweaks or extra includes. It's disabled now to avoid giving - // a false sense of security. -# define FC_HAS_SIMPLE_FILE_LOCK -#endif -#ifdef FC_HAS_SIMPLE_FILE_LOCK - /** simple class which only allows one process to open any given file. - * approximate usage: - * int main() { - * fc::simple_file_lock instance_lock("~/.my_app/.lock"); - * if (!instance_lock.try_lock()) { - * elog("my_app is already running"); - * return 1; - * } - * // do stuff here, file will be unlocked when instance_lock goes out of scope - * } - */ - class simple_lock_file - { - public: - simple_lock_file(const path& lock_file_path); - ~simple_lock_file(); - bool try_lock(); - void unlock(); - private: - class impl; - std::unique_ptr my; - }; -#endif // FC_HAS_SIMPLE_FILE_LOCK - } diff --git a/include/fc/fixed_string.hpp b/include/fc/fixed_string.hpp deleted file mode 100644 index a91b651..0000000 --- a/include/fc/fixed_string.hpp +++ /dev/null @@ -1,143 +0,0 @@ -#pragma once -#include - - -namespace fc { - - - /** - * This class is designed to offer in-place memory allocation of a string up to Length equal to - * sizeof(Storage). - * - * The string will serialize the same way as std::string for variant and raw formats - * The string will sort according to the comparison operators defined for Storage, this enables effecient - * sorting. - */ - template > - class fixed_string { - public: - fixed_string(){} - fixed_string( const fixed_string& c ):data(c.data){} - - fixed_string( const std::string& str ) { - if( str.size() <= sizeof(data) ) - memcpy( (char*)&data, str.c_str(), str.size() ); - else { - memcpy( (char*)&data, str.c_str(), sizeof(data) ); - } - } - fixed_string( const char* str ) { - auto l = strlen(str); - if( l <= sizeof(data) ) - memcpy( (char*)&data, str, l ); - else { - memcpy( (char*)&data, str, sizeof(data) ); - } - } - - operator std::string()const { - const char* self = (const char*)&data; - return std::string( self, self + size() ); - } - - uint32_t size()const { - if( *(((const char*)&data)+sizeof(data) - 1) ) - return sizeof(data); - return strnlen( (const char*)&data, sizeof(data) ); - } - uint32_t length()const { return size(); } - - fixed_string& operator=( const fixed_string& str ) { - data = str.data; - return *this; - } - fixed_string& operator=( const char* str ) { - return *this = fixed_string(str); - } - - fixed_string& operator=( const std::string& str ) { - if( str.size() <= sizeof(data) ) { - data = Storage(); - memcpy( (char*)&data, str.c_str(), str.size() ); - } - else { - memcpy( (char*)&data, str.c_str(), sizeof(data) ); - } - return *this; - } - - friend std::string operator + ( const fixed_string& a, const std::string& b ) { - return std::string(a) + b; - } - friend std::string operator + ( const std::string& a, const fixed_string& b ) { - return a + std::string(b); - } - - friend bool operator < ( const fixed_string& a, const fixed_string& b ) { - return a.data < b.data; - } - friend bool operator <= ( const fixed_string& a, const fixed_string& b ) { - return a.data <= b.data; - } - friend bool operator > ( const fixed_string& a, const fixed_string& b ) { - return a.data > b.data; - } - friend bool operator >= ( const fixed_string& a, const fixed_string& b ) { - return a.data >= b.data; - } - friend bool operator == ( const fixed_string& a, const fixed_string& b ) { - return a.data == b.data; - } - friend bool operator != ( const fixed_string& a, const fixed_string& b ) { - return a.data != b.data; - } - //private: - Storage data; - }; - - namespace raw - { - template - inline void pack( Stream& s, const fc::fixed_string& u, uint32_t _max_depth=FC_PACK_MAX_DEPTH ) { - FC_ASSERT( _max_depth > 0 ); - unsigned_int size = u.size(); - pack( s, size, _max_depth - 1 ); - s.write( (const char*)&u.data, size ); - } - - template - inline void unpack( Stream& s, fc::fixed_string& u, uint32_t _max_depth=FC_PACK_MAX_DEPTH ) { - FC_ASSERT( _max_depth > 0 ); - unsigned_int size; - fc::raw::unpack( s, size, _max_depth - 1 ); - if( size.value > 0 ) { - if( size.value > sizeof(Storage) ) { - s.read( (char*)&u.data, sizeof(Storage) ); - char buf[1024]; - size_t left = size.value - sizeof(Storage); - while( left >= 1024 ) - { - s.read( buf, 1024 ); - left -= 1024; - } - s.read( buf, left ); - } else { - s.read( (char*)&u.data, size.value ); - } - } - } - } -} - -#include -namespace fc { - template - void to_variant( const fixed_string& s, variant& v, uint32_t max_depth = 1 ) { - v = std::string(s); - } - - template - void from_variant( const variant& v, fixed_string& s, uint32_t max_depth = 1 ) { - s = v.as_string(); - } -} diff --git a/include/fc/fwd.hpp b/include/fc/fwd.hpp index ccf0828..b1a4006 100644 --- a/include/fc/fwd.hpp +++ b/include/fc/fwd.hpp @@ -1,5 +1,4 @@ #pragma once -#include namespace fc { @@ -37,7 +36,7 @@ class fwd { ~fwd(); private: - aligned _store; + alignas(Align) char _store[S]; }; diff --git a/include/fc/fwd_impl.hpp b/include/fc/fwd_impl.hpp index 639085a..1c8155d 100644 --- a/include/fc/fwd_impl.hpp +++ b/include/fc/fwd_impl.hpp @@ -3,31 +3,32 @@ #include #include #include +#include namespace fc { namespace detail { template struct add { - typedef decltype( *((A*)0) + *((typename fc::remove_reference::type*)0) ) type; + typedef decltype( *((A*)0) + *((typename std::remove_reference::type*)0) ) type; }; template struct add_eq { - typedef decltype( *((A*)0) += *((typename fc::remove_reference::type*)0) ) type; + typedef decltype( *((A*)0) += *((typename std::remove_reference::type*)0) ) type; }; template struct sub { - typedef decltype( *((A*)0) - *((typename fc::remove_reference::type*)0) ) type; + typedef decltype( *((A*)0) - *((typename std::remove_reference::type*)0) ) type; }; template struct sub_eq { - typedef decltype( *((A*)0) -= *((typename fc::remove_reference::type*)0) ) type; + typedef decltype( *((A*)0) -= *((typename std::remove_reference::type*)0) ) type; }; template struct insert_op { - typedef decltype( *((A*)0) << *((typename fc::remove_reference::type*)0) ) type; + typedef decltype( *((A*)0) << *((typename std::remove_reference::type*)0) ) type; }; template struct extract_op { @@ -91,7 +92,7 @@ namespace fc { template fwd::fwd( fwd&& f ){ check_size(); - new (this) T( fc::move(*f) ); + new (this) T( std::move(*f) ); } @@ -124,7 +125,7 @@ namespace fc { template T& fwd::operator = ( fwd&& u ) { - return **this = fc::move(*u); + return **this = std::move(*u); } template T& fwd::operator = ( const fwd& u ) { diff --git a/include/fc/interprocess/container.hpp b/include/fc/interprocess/container.hpp deleted file mode 100644 index a1a4658..0000000 --- a/include/fc/interprocess/container.hpp +++ /dev/null @@ -1,108 +0,0 @@ -#pragma once - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -namespace fc { - - namespace bip = boost::interprocess; - - template - void to_variant( const bip::deque< T... >& t, fc::variant& v, uint32_t max_depth ) { - FC_ASSERT( max_depth > 0, "Recursion depth exceeded!" ); - --max_depth; - std::vector vars(t.size()); - for( size_t i = 0; i < t.size(); ++i ) { - to_variant( t[i], vars[i], max_depth ); - } - v = std::move(vars); - } - - template - void from_variant( const fc::variant& v, bip::deque< T, A... >& d, uint32_t max_depth ) { - FC_ASSERT( max_depth > 0, "Recursion depth exceeded!" ); - --max_depth; - const variants& vars = v.get_array(); - d.clear(); - d.resize( vars.size() ); - for( uint32_t i = 0; i < vars.size(); ++i ) { - from_variant( vars[i], d[i], max_depth ); - } - } - - template - void to_variant( const bip::map< K, V, T... >& var, fc::variant& vo, uint32_t max_depth ) { - FC_ASSERT( max_depth > 0, "Recursion depth exceeded!" ); - --max_depth; - std::vector< variant > vars(var.size()); - size_t i = 0; - for( auto itr = var.begin(); itr != var.end(); ++itr, ++i ) - vars[i] = fc::variant( *itr, max_depth ); - vo = vars; - } - - template - void to_variant( const bip::vector< T... >& t, fc::variant& v, uint32_t max_depth ) { - FC_ASSERT( max_depth > 0, "Recursion depth exceeded!" ); - --max_depth; - std::vector vars(t.size()); - for( size_t i = 0; i < t.size(); ++i ) { - to_variant( t[i], vars[i], max_depth ); - } - v = std::move(vars); - } - - template - void from_variant( const fc::variant& v, bip::vector< T, A... >& d, uint32_t max_depth ) { - FC_ASSERT( max_depth > 0, "Recursion depth exceeded!" ); - --max_depth; - const variants& vars = v.get_array(); - d.clear(); - d.resize( vars.size() ); - for( uint32_t i = 0; i < vars.size(); ++i ) { - from_variant( vars[i], d[i], max_depth ); - } - } - - template - void to_variant( const bip::set< T... >& t, fc::variant& v, uint32_t max_depth ) { - FC_ASSERT( max_depth > 0, "Recursion depth exceeded!" ); - --max_depth; - std::vector vars; - vars.reserve(t.size()); - for( const auto& item : t ) { - vars.emplace_back( variant( item, max_depth ) ); - } - v = std::move(vars); - } - - template - void to_variant( const bip::vector& t, fc::variant& v, uint32_t max_depth = 1 ) - { - if( t.size() ) - v = variant(fc::to_hex(t.data(), t.size())); - else - v = ""; - } - - template - void from_variant( const fc::variant& v, bip::vector& d, uint32_t max_depth = 1 ) - { - auto str = v.as_string(); - d.resize( str.size() / 2 ); - if( d.size() ) - { - size_t r = fc::from_hex( str, d.data(), d.size() ); - FC_ASSERT( r == d.size() ); - } - } -} diff --git a/include/fc/interprocess/file_mapping.hpp b/include/fc/interprocess/file_mapping.hpp index e6b6817..369e6fa 100644 --- a/include/fc/interprocess/file_mapping.hpp +++ b/include/fc/interprocess/file_mapping.hpp @@ -1,6 +1,7 @@ #pragma once #include -#include +#include +#include namespace boost { namespace interprocess { @@ -24,7 +25,7 @@ namespace fc { #ifdef _WIN64 fc::fwd my; #else - fc::fwd my; + fc::fwd my; #endif }; diff --git a/include/fc/interprocess/file_mutex.hpp b/include/fc/interprocess/file_mutex.hpp deleted file mode 100644 index 6041824..0000000 --- a/include/fc/interprocess/file_mutex.hpp +++ /dev/null @@ -1,44 +0,0 @@ -#pragma once -#include -#include - -#include - -namespace fc { - class microseconds; - class time_point; - class path; - struct context; - - namespace detail { class file_mutex_impl; } - - /** - * The purpose of this class is to support synchronization of - * processes, threads, and coop-threads. - * - * Before grabbing the lock for a thread or coop, a file_mutex will first - * grab a process-level lock. After grabbing the process level lock, it will - * synchronize in the same way as a local process lock. - */ - class file_mutex { - public: - file_mutex( const fc::path& filename ); - ~file_mutex(); - - bool try_lock(); - bool try_lock_for( const microseconds& rel_time ); - bool try_lock_until( const time_point& abs_time ); - void lock(); - void unlock(); - - void lock_shared(); - void unlock_shared(); - bool try_lock_shared(); - - int readers()const; - - private: - std::unique_ptr my; - }; - -} // namespace fc diff --git a/include/fc/interprocess/iprocess.hpp b/include/fc/interprocess/iprocess.hpp deleted file mode 100644 index c7f8c4e..0000000 --- a/include/fc/interprocess/iprocess.hpp +++ /dev/null @@ -1,67 +0,0 @@ -#pragma once -#include -#include -#include -#include -#include - -namespace fc -{ - /** - * @brief abstract interface for interacting with external processes - * - * At the very least we have ssh::process and direct child processes, and - * there may be other processes that need to implement this protocol. - */ - class iprocess - { - public: - enum exec_opts { - open_none = 0, - open_stdin = 0x01, - open_stdout = 0x02, - open_stderr = 0x04, - open_all = open_stdin|open_stdout|open_stderr, - suppress_console = 0x08 - }; - - virtual ~iprocess(){} - - /** - * - * @return *this - */ - virtual iprocess& exec( const path& exe, std::vector args, - const path& work_dir = path(), int opts = open_all ) = 0; - - /** - * @return blocks until the process exits - */ - virtual int result(const microseconds& timeout = microseconds::maximum()) = 0; - - - /** - * Forcefully kills the process. - */ - virtual void kill() = 0; - - /** - * @brief returns a stream that writes to the process' stdin - */ - virtual buffered_ostream_ptr in_stream() = 0; - - /** - * @brief returns a stream that reads from the process' stdout - */ - virtual buffered_istream_ptr out_stream() = 0; - /** - * @brief returns a stream that reads from the process' stderr - */ - virtual buffered_istream_ptr err_stream() = 0; - - }; - - typedef std::shared_ptr iprocess_ptr; - - -} // namespace fc diff --git a/include/fc/interprocess/mmap_struct.hpp b/include/fc/interprocess/mmap_struct.hpp deleted file mode 100644 index 0913deb..0000000 --- a/include/fc/interprocess/mmap_struct.hpp +++ /dev/null @@ -1,59 +0,0 @@ -#pragma once -#include -#include - -namespace fc -{ - class path; - namespace detail - { - /** - * Base class used to hide common implementation details. - */ - class mmap_struct_base - { - public: - size_t size()const; - void flush(); - - protected: - void open( const fc::path& file, size_t s, bool create ); - std::unique_ptr _file_mapping; - std::unique_ptr _mapped_region; - }; - }; - - /** - * @class mmap_struct - * @brief A struct that has been mapped from a file. - * - * @note T must be POD - */ - template - class mmap_struct : public detail::mmap_struct_base - { - public: - mmap_struct():_mapped_struct(nullptr){} - /** - * Create the file if it does not exist or is of the wrong size if create is true, then maps - * the file to memory. - * - * @throw an exception if the file does not exist or is the wrong size and create is false - */ - void open( const fc::path& file, bool create = false ) - { - detail::mmap_struct_base::open( file, sizeof(T), create ); - _mapped_struct = (T*)_mapped_region->get_address(); - } - - T* operator->() { return _mapped_struct; } - const T* operator->()const { return _mapped_struct; } - - T& operator*() { return *_mapped_struct; } - const T& operator*()const { return *_mapped_struct; } - - private: - T* _mapped_struct; - }; - -} diff --git a/include/fc/interprocess/process.hpp b/include/fc/interprocess/process.hpp deleted file mode 100644 index 777c154..0000000 --- a/include/fc/interprocess/process.hpp +++ /dev/null @@ -1,37 +0,0 @@ -#pragma once -#include - -namespace fc { - - fc::path find_executable_in_path( const fc::string name ); - - /** - * @brief start and manage an local process - * @note this class implements reference semantics. - */ - class process : public iprocess - { - public: - process(); - ~process(); - - virtual iprocess& exec( const fc::path& exe, - std::vector args, - const fc::path& work_dir = fc::path(), - int opts = open_all ); - - - virtual int result(const microseconds& timeout = microseconds::maximum()); - virtual void kill(); - virtual fc::buffered_ostream_ptr in_stream(); - virtual fc::buffered_istream_ptr out_stream(); - virtual fc::buffered_istream_ptr err_stream(); - - class impl; - private: - std::unique_ptr my; - }; - - typedef std::shared_ptr process_ptr; - -} // namespace fc diff --git a/include/fc/io/console.hpp b/include/fc/io/console.hpp deleted file mode 100644 index 11a9d47..0000000 --- a/include/fc/io/console.hpp +++ /dev/null @@ -1,8 +0,0 @@ -#pragma once -namespace fc -{ - /** enables / disables echoing of console input, useful for - * entering passwords on the console. - */ - void set_console_echo( bool enable_echo ); -} // namespace fc diff --git a/include/fc/io/iobuffer.hpp b/include/fc/io/iobuffer.hpp deleted file mode 100644 index 02f919b..0000000 --- a/include/fc/io/iobuffer.hpp +++ /dev/null @@ -1,81 +0,0 @@ -#pragma once -#include -#include - -namespace fc -{ - /** - * Records the size, but discards the data. - */ - class size_stream : public virtual fc::ostream - { - public: - size_stream( size_t s = 0):_size(s){} - - size_t size()const { return _size; } - size_t seek( size_t pos ) { return _size = pos; } - - virtual size_t writesome( const char* /*ignored buf*/, size_t len ) - { - _size += len; - return len; - } - - virtual void close(){} - virtual void flush(){} - - private: - size_t _size; - }; - - - class iobuffer : public virtual fc::iostream - { - public: - iobuffer( size_t s ) - :_data(s){} - - size_t size()const { return _data.size(); } - size_t pos()const { return _pos; } - size_t seek( size_t pos ) - { - return _pos = std::min(_data.size(),pos); - } - - virtual size_t readsome( char* buf, size_t len ) - { - auto avail = std::min( _data.size()-_pos, len ); - if( avail == 0 ) throw fc::eof_exception(); - memcpy( buf, _data.data()+_pos, avail ); - _pos += avail; - return avail; - } - /** - * This method may block until at least 1 character is - * available. - */ - char peek()const - { - if( _pos == _data.size() ) throw fc::eof_exception(); - return _data[_pos]; - } - - virtual size_t writesome( const char* buf, size_t len ) - { - auto avail = std::max( _data.size(), _pos + len ); - _data.resize(avail); - memcpy( _data.data()+_pos, buf, len ); - _pos += avail; - return avail; - } - char* data() { return _data.data(); } - - virtual void close(){} - virtual void flush(){} - - private: - std::vector _data; - size_t _pos; - }; - -} diff --git a/include/fc/io/iostream.hpp b/include/fc/io/iostream.hpp index 1ec632f..9fa592b 100644 --- a/include/fc/io/iostream.hpp +++ b/include/fc/io/iostream.hpp @@ -1,6 +1,4 @@ #pragma once -#include -#include #include namespace fc { @@ -61,7 +59,7 @@ namespace fc { class iostream : public virtual ostream, public virtual istream {}; - fc::istream& getline( fc::istream&, fc::string&, char delim = '\n' ); + fc::istream& getline( fc::istream&, std::string&, char delim = '\n' ); template ostream& operator<<( ostream& o, char (&array)[N] ) @@ -72,7 +70,7 @@ namespace fc { ostream& operator<<( ostream& o, char ); ostream& operator<<( ostream& o, const char* v ); ostream& operator<<( ostream& o, const std::string& v ); - ostream& operator<<( ostream& o, const fc::string& v ); + ostream& operator<<( ostream& o, const std::string& v ); ostream& operator<<( ostream& o, const double& v ); ostream& operator<<( ostream& o, const float& v ); ostream& operator<<( ostream& o, const int64_t& v ); @@ -88,7 +86,7 @@ namespace fc { #endif istream& operator>>( istream& o, std::string& v ); - istream& operator>>( istream& o, fc::string& v ); + istream& operator>>( istream& o, std::string& v ); istream& operator>>( istream& o, char& v ); istream& operator>>( istream& o, double& v ); istream& operator>>( istream& o, float& v ); diff --git a/include/fc/io/json.hpp b/include/fc/io/json.hpp index f07124b..0f97c40 100644 --- a/include/fc/io/json.hpp +++ b/include/fc/io/json.hpp @@ -33,7 +33,7 @@ namespace fc legacy_generator = 1 }; - static ostream& to_stream( ostream& out, const fc::string& ); + static ostream& to_stream( ostream& out, const std::string& ); static ostream& to_stream( ostream& out, const variant& v, output_formatting format = stringify_large_ints_and_doubles, uint32_t max_depth = DEFAULT_MAX_RECURSION_DEPTH ); static ostream& to_stream( ostream& out, const variants& v, output_formatting format = stringify_large_ints_and_doubles, uint32_t max_depth = DEFAULT_MAX_RECURSION_DEPTH ); static ostream& to_stream( ostream& out, const variant_object& v, output_formatting format = stringify_large_ints_and_doubles, uint32_t max_depth = DEFAULT_MAX_RECURSION_DEPTH ); diff --git a/include/fc/io/json_relaxed.hpp b/include/fc/io/json_relaxed.hpp index 9a25666..00893a3 100644 --- a/include/fc/io/json_relaxed.hpp +++ b/include/fc/io/json_relaxed.hpp @@ -10,7 +10,6 @@ #include #include #include -#include //#include #include #include @@ -24,7 +23,7 @@ namespace fc { namespace json_relaxed variant variant_from_stream( T& in, uint32_t max_depth ); template - fc::string tokenFromStream( T& in ) + std::string tokenFromStream( T& in ) { fc::stringstream token; try @@ -81,7 +80,7 @@ namespace fc { namespace json_relaxed } template - fc::string quoteStringFromStream( T& in ) + std::string quoteStringFromStream( T& in ) { fc::stringstream token; try @@ -107,11 +106,11 @@ namespace fc { namespace json_relaxed try { if( in.peek() != q ) - return fc::string(); + return std::string(); } catch( const fc::eof_exception& e ) { - return fc::string(); + return std::string(); } // triple quote processing @@ -186,7 +185,7 @@ namespace fc { namespace json_relaxed } template - fc::string stringFromStream( T& in ) + std::string stringFromStream( T& in ) { try { @@ -294,7 +293,7 @@ namespace fc { namespace json_relaxed }; template - fc::variant parseInt( const fc::string& token, size_t start ) + fc::variant parseInt( const std::string& token, size_t start ) { static const CharValueTable ctbl; static const uint64_t INT64_MAX_PLUS_ONE = static_cast(INT64_MAX) + 1; @@ -336,7 +335,7 @@ namespace fc { namespace json_relaxed } template - fc::variant maybeParseInt( const fc::string& token, size_t start ) + fc::variant maybeParseInt( const std::string& token, size_t start ) { try { @@ -352,7 +351,7 @@ namespace fc { namespace json_relaxed } template - fc::variant parseNumberOrStr( const fc::string& token ) + fc::variant parseNumberOrStr( const std::string& token ) { try { //ilog( (token) ); size_t i = 0, n = token.length(); @@ -588,7 +587,7 @@ namespace fc { namespace json_relaxed template variant numberFromStream( T& in ) { try { - fc::string token = tokenFromStream(in); + std::string token = tokenFromStream(in); variant result = json_relaxed::parseNumberOrStr( token ); if( strict && !(result.is_int64() || result.is_uint64() || result.is_double()) ) FC_THROW_EXCEPTION( parse_error_exception, "expected: number" ); @@ -598,7 +597,7 @@ namespace fc { namespace json_relaxed template variant wordFromStream( T& in ) { - fc::string token = tokenFromStream(in); + std::string token = tokenFromStream(in); FC_ASSERT( token.length() > 0 ); diff --git a/include/fc/io/raw.hpp b/include/fc/io/raw.hpp index 24aff5e..052110c 100644 --- a/include/fc/io/raw.hpp +++ b/include/fc/io/raw.hpp @@ -50,7 +50,7 @@ namespace fc { fc::raw::unpack( s, what, _max_depth ); fc::raw::unpack( s, msgs, _max_depth ); - e = fc::exception( fc::move(msgs), code, name, what ); + e = fc::exception( std::move(msgs), code, name, what ); } template @@ -206,7 +206,7 @@ namespace fc { template inline void pack( Stream& s, const char* v, uint32_t _max_depth ) { FC_ASSERT( _max_depth > 0 ); - fc::raw::pack( s, fc::string(v), _max_depth - 1 ); + fc::raw::pack( s, std::string(v), _max_depth - 1 ); } template @@ -270,18 +270,18 @@ namespace fc { } // fc::string - template inline void pack( Stream& s, const fc::string& v, uint32_t _max_depth ) { + template inline void pack( Stream& s, const std::string& v, uint32_t _max_depth ) { FC_ASSERT( _max_depth > 0 ); fc::raw::pack( s, unsigned_int(v.size()), _max_depth - 1 ); if( v.size() ) s.write( v.c_str(), v.size() ); } - template inline void unpack( Stream& s, fc::string& v, uint32_t _max_depth ) { + template inline void unpack( Stream& s, std::string& v, uint32_t _max_depth ) { FC_ASSERT( _max_depth > 0 ); std::vector tmp; fc::raw::unpack( s, tmp, _max_depth - 1 ); if( tmp.size() ) - v = fc::string( tmp.data(), tmp.data()+tmp.size() ); - else v = fc::string(); + v = std::string( tmp.data(), tmp.data()+tmp.size() ); + else v = std::string(); } // bool diff --git a/include/fc/io/raw_fwd.hpp b/include/fc/io/raw_fwd.hpp index df80768..17f2395 100644 --- a/include/fc/io/raw_fwd.hpp +++ b/include/fc/io/raw_fwd.hpp @@ -1,7 +1,6 @@ #pragma once #include #include -#include #include #include #include @@ -31,15 +30,11 @@ namespace fc { namespace ip { class endpoint; } namespace ecc { class public_key; class private_key; } - template class fixed_string; namespace raw { template inline size_t pack_size( const T& v ); - template inline void pack( Stream& s, const fc::fixed_string& u, uint32_t _max_depth=FC_PACK_MAX_DEPTH ); - template inline void unpack( Stream& s, fc::fixed_string& u, uint32_t _max_depth=FC_PACK_MAX_DEPTH ); - template inline void pack( Stream& s, const fc::enum_type& tp, uint32_t _max_depth=FC_PACK_MAX_DEPTH ); template @@ -58,8 +53,8 @@ namespace fc { //template inline void pack( Stream& s, const flat_set& value, uint32_t _max_depth=FC_PACK_MAX_DEPTH ); //template inline void unpack( Stream& s, flat_set& value, uint32_t _max_depth=FC_PACK_MAX_DEPTH ); - //template inline void pack( Stream& s, const std::deque& value, uint32_t _max_depth=FC_PACK_MAX_DEPTH ); - //template inline void unpack( Stream& s, std::deque& value, uint32_t _max_depth=FC_PACK_MAX_DEPTH ); + template inline void pack( Stream& s, const std::deque& value, uint32_t _max_depth=FC_PACK_MAX_DEPTH ); + template inline void unpack( Stream& s, std::deque& value, uint32_t _max_depth=FC_PACK_MAX_DEPTH ); template inline void pack( Stream& s, const std::unordered_map& value, uint32_t _max_depth=FC_PACK_MAX_DEPTH ); template inline void unpack( Stream& s, std::unordered_map& value, uint32_t _max_depth=FC_PACK_MAX_DEPTH ); diff --git a/include/fc/io/raw_unpack_file.hpp b/include/fc/io/raw_unpack_file.hpp deleted file mode 100644 index 580a64c..0000000 --- a/include/fc/io/raw_unpack_file.hpp +++ /dev/null @@ -1,24 +0,0 @@ -#pragma once -#include -#include -#include -#include - -namespace fc -{ - namespace raw - { - template - void unpack_file( const fc::path& filename, T& obj ) - { - try { - fc::file_mapping fmap( filename.generic_string().c_str(), fc::read_only); - fc::mapped_region mapr( fmap, fc::read_only, 0, fc::file_size(filename) ); - auto cs = (const char*)mapr.get_address(); - - fc::datastream ds( cs, mapr.get_size() ); - fc::raw::unpack(ds,obj); - } FC_RETHROW_EXCEPTIONS( info, "unpacking file ${file}", ("file",filename) ); - } - } -} diff --git a/include/fc/io/raw_variant.hpp b/include/fc/io/raw_variant.hpp index 4bf9fd8..f4a7e02 100644 --- a/include/fc/io/raw_variant.hpp +++ b/include/fc/io/raw_variant.hpp @@ -100,23 +100,23 @@ namespace fc { namespace raw { } case variant::string_type: { - fc::string val; + std::string val; raw::unpack( s, val, _max_depth ); - v = fc::move(val); + v = std::move(val); return; } case variant::array_type: { variants val; raw::unpack( s, val, _max_depth ); - v = fc::move(val); + v = std::move(val); return; } case variant::object_type: { variant_object val; raw::unpack( s, val, _max_depth ); - v = fc::move(val); + v = std::move(val); return; } default: @@ -148,13 +148,13 @@ namespace fc { namespace raw { mvo.reserve( std::min( vs.value, static_cast(FC_MAX_PREALLOC_SIZE) ) ); for( uint32_t i = 0; i < vs.value; ++i ) { - fc::string key; + std::string key; fc::variant value; fc::raw::unpack( s, key, _max_depth ); fc::raw::unpack( s, value, _max_depth ); - mvo.set( fc::move(key), fc::move(value) ); + mvo.set( std::move(key), std::move(value) ); } - v = fc::move(mvo); + v = std::move(mvo); } } } // fc::raw diff --git a/include/fc/io/sstream.hpp b/include/fc/io/sstream.hpp index 285c481..f5a2a89 100644 --- a/include/fc/io/sstream.hpp +++ b/include/fc/io/sstream.hpp @@ -7,12 +7,12 @@ namespace fc { class stringstream : virtual public iostream { public: stringstream(); - stringstream( fc::string& s); - stringstream( const fc::string& s); + stringstream( std::string& s); + stringstream( const std::string& s); ~stringstream(); - fc::string str(); - void str(const fc::string& s); + std::string str(); + void str(const std::string& s); void clear(); diff --git a/include/fc/log/appender.hpp b/include/fc/log/appender.hpp index f1f5aa8..8f57f4c 100644 --- a/include/fc/log/appender.hpp +++ b/include/fc/log/appender.hpp @@ -1,6 +1,6 @@ #pragma once #include -#include +#include namespace fc { class appender; @@ -30,13 +30,13 @@ namespace fc { typedef fc::shared_ptr ptr; template - static bool register_appender(const fc::string& type) { + static bool register_appender(const std::string& type) { return register_appender( type, new detail::appender_factory_impl() ); } - static appender::ptr create( const fc::string& name, const fc::string& type, const variant& args ); - static appender::ptr get( const fc::string& name ); - static bool register_appender( const fc::string& type, const appender_factory::ptr& f ); + static appender::ptr create( const std::string& name, const std::string& type, const variant& args ); + static appender::ptr get( const std::string& name ); + static bool register_appender( const std::string& type, const appender_factory::ptr& f ); virtual void log( const log_message& m ) = 0; }; diff --git a/include/fc/log/console_appender.hpp b/include/fc/log/console_appender.hpp index 4048da6..75ecbbd 100644 --- a/include/fc/log/console_appender.hpp +++ b/include/fc/log/console_appender.hpp @@ -40,7 +40,7 @@ namespace fc :format( "${timestamp} ${thread_name} ${context} ${file}:${line} ${method} ${level}] ${message}" ), stream(console_appender::stream::std_error),max_object_depth(FC_MAX_LOG_OBJECT_DEPTH),flush(true){} - fc::string format; + std::string format; console_appender::stream::type stream; std::vector level_colors; uint32_t max_object_depth; diff --git a/include/fc/log/file_appender.hpp b/include/fc/log/file_appender.hpp index 6f1fa6f..bd692ef 100644 --- a/include/fc/log/file_appender.hpp +++ b/include/fc/log/file_appender.hpp @@ -12,7 +12,7 @@ class file_appender : public appender { struct config { config( const fc::path& p = "log.txt" ); - fc::string format; + std::string format; fc::path filename; bool flush = true; bool rotate = false; diff --git a/include/fc/log/log_message.hpp b/include/fc/log/log_message.hpp index e9e1a68..7c529c0 100644 --- a/include/fc/log/log_message.hpp +++ b/include/fc/log/log_message.hpp @@ -8,6 +8,7 @@ #include #include #include +#include namespace fc { @@ -65,19 +66,19 @@ namespace fc explicit log_context( const variant& v, uint32_t max_depth ); variant to_variant( uint32_t max_depth )const; - string get_file()const; + std::string get_file()const; uint64_t get_line_number()const; - string get_method()const; - string get_thread_name()const; - string get_task_name()const; - string get_host_name()const; + std::string get_method()const; + std::string get_thread_name()const; + std::string get_task_name()const; + std::string get_host_name()const; time_point get_timestamp()const; log_level get_log_level()const; - string get_context()const; + std::string get_context()const; - void append_context( const fc::string& c ); + void append_context( const std::string& c ); - string to_string()const; + std::string to_string()const; private: std::shared_ptr my; }; @@ -116,10 +117,10 @@ namespace fc log_message( const variant& v, uint32_t max_depth ); variant to_variant(uint32_t max_depth)const; - string get_message()const; + std::string get_message()const; log_context get_context()const; - string get_format()const; + std::string get_format()const; variant_object get_data()const; private: diff --git a/include/fc/log/logger.hpp b/include/fc/log/logger.hpp index 16275dc..6e1a52b 100644 --- a/include/fc/log/logger.hpp +++ b/include/fc/log/logger.hpp @@ -1,6 +1,5 @@ #pragma once #include -#include #include #include #include @@ -23,7 +22,7 @@ namespace fc class logger { public: - static logger get( const fc::string& name = "default"); + static logger get( const std::string& name = "default"); logger(); logger( const string& name, const logger& parent = nullptr ); @@ -41,8 +40,8 @@ namespace fc logger& set_parent( const logger& l ); logger get_parent()const; - void set_name( const fc::string& n ); - const fc::string& name()const; + void set_name( const std::string& n ); + const std::string& name()const; void add_appender( const fc::shared_ptr& a ); std::vector > get_appenders()const; diff --git a/include/fc/log/logger_config.hpp b/include/fc/log/logger_config.hpp index f2fc1e2..8f73055 100644 --- a/include/fc/log/logger_config.hpp +++ b/include/fc/log/logger_config.hpp @@ -9,7 +9,7 @@ namespace fc { variant args = variant()) : name(name), type(type), - args(fc::move(args)), + args(std::move(args)), enabled(true) {} string name; @@ -19,7 +19,7 @@ namespace fc { }; struct logger_config { - logger_config(const fc::string& name = ""):name(name),enabled(true),additivity(false){} + logger_config(const std::string& name = ""):name(name),enabled(true),additivity(false){} string name; ostring parent; /// if not set, then parents level is used. diff --git a/include/fc/make_fused.hpp b/include/fc/make_fused.hpp deleted file mode 100644 index acbf901..0000000 --- a/include/fc/make_fused.hpp +++ /dev/null @@ -1,26 +0,0 @@ -#pragma once -#include -#include - -namespace fc { - template - std::function > make_fused( const std::function& f ) { - return [=]( fc::tuple<> ){ return f(); }; - } - template - std::function) > make_fused( const std::function& f ) { - return [f]( fc::tuple t){ return f(t.a); }; - } - template - std::function) > make_fused( const std::function& f ) { - return [f]( fc::tuple t){ return f(t.a,t.b); }; - } - template - std::function) > make_fused( const std::function& f ) { - return [f]( fc::tuple t){ return f(t.a,t.b,t.c); }; - } - template - std::function) > make_fused( const std::function& f ) { - return [f]( fc::tuple t){ return f(t.a,t.b,t.c,t.d); }; - } -} diff --git a/include/fc/network/http/connection.hpp b/include/fc/network/http/connection.hpp index 786f24d..8a34076 100644 --- a/include/fc/network/http/connection.hpp +++ b/include/fc/network/http/connection.hpp @@ -1,7 +1,6 @@ #pragma once -#include -#include #include +#include namespace fc { namespace ip { class endpoint; } @@ -11,11 +10,11 @@ namespace fc { struct header { - header( fc::string k, fc::string v ) - :key(fc::move(k)),val(fc::move(v)){} + header( std::string k, std::string v ) + :key(std::move(k)),val(std::move(v)){} header(){} - fc::string key; - fc::string val; + std::string key; + std::string val; }; typedef std::vector
headers; @@ -39,16 +38,16 @@ namespace fc { struct request { - fc::string get_header( const fc::string& key )const; - fc::string remote_endpoint; - fc::string method; - fc::string domain; - fc::string path; + std::string get_header( const std::string& key )const; + std::string remote_endpoint; + std::string method; + std::string domain; + std::string path; std::vector
headers; std::vector body; }; - std::vector
parse_urlencoded_params( const fc::string& f ); + std::vector
parse_urlencoded_params( const std::string& f ); /** * Connections have reference semantics, all copies refer to the same @@ -61,7 +60,7 @@ namespace fc { ~connection(); // used for clients void connect_to( const fc::ip::endpoint& ep ); - http::reply request( const fc::string& method, const fc::string& url, const fc::string& body = std::string(), const headers& = headers()); + http::reply request( const std::string& method, const std::string& url, const std::string& body = std::string(), const headers& = headers()); // used for servers fc::tcp_socket& get_socket()const; diff --git a/include/fc/network/http/server.hpp b/include/fc/network/http/server.hpp index b5eda8b..a52ebcc 100644 --- a/include/fc/network/http/server.hpp +++ b/include/fc/network/http/server.hpp @@ -35,7 +35,7 @@ namespace fc { namespace http { response& operator=(const response& ); response& operator=( response&& ); - void add_header( const fc::string& key, const fc::string& val )const; + void add_header( const std::string& key, const std::string& val )const; void set_status( const http::reply::status_code& s )const; void set_length( uint64_t s )const; diff --git a/include/fc/network/http/websocket.hpp b/include/fc/network/http/websocket.hpp index f56b4be..8837057 100644 --- a/include/fc/network/http/websocket.hpp +++ b/include/fc/network/http/websocket.hpp @@ -2,7 +2,7 @@ #include #include #include -#include +#include #include #include @@ -26,14 +26,14 @@ namespace fc { namespace http { void on_message_handler( const std::function& h ) { _on_message = h; } void on_http_handler( const std::function& h ) { _on_http = h; } - void set_session_data( fc::any d ){ _session_data = std::move(d); } - fc::any& get_session_data() { return _session_data; } + void set_session_data( boost::any d ){ _session_data = std::move(d); } + boost::any& get_session_data() { return _session_data; } virtual std::string get_request_header(const std::string& key) = 0; fc::signal closed; private: - fc::any _session_data; + boost::any _session_data; std::function _on_message; std::function _on_http; }; diff --git a/include/fc/network/ip.hpp b/include/fc/network/ip.hpp index 7a55616..e183220 100644 --- a/include/fc/network/ip.hpp +++ b/include/fc/network/ip.hpp @@ -1,5 +1,4 @@ #pragma once -#include #include #include #include @@ -11,10 +10,10 @@ namespace fc { class address { public: address( uint32_t _ip = 0 ); - address( const fc::string& s ); + address( const std::string& s ); - address& operator=( const fc::string& s ); - operator fc::string()const; + address& operator=( const std::string& s ); + operator std::string()const; operator uint32_t()const; friend bool operator==( const address& a, const address& b ); diff --git a/include/fc/network/resolve.hpp b/include/fc/network/resolve.hpp index f6bf6ec..0d0c7c7 100644 --- a/include/fc/network/resolve.hpp +++ b/include/fc/network/resolve.hpp @@ -1,5 +1,4 @@ #pragma once -#include #include namespace fc diff --git a/include/fc/network/tcp_socket.hpp b/include/fc/network/tcp_socket.hpp index 4c2e7d6..59fcb73 100644 --- a/include/fc/network/tcp_socket.hpp +++ b/include/fc/network/tcp_socket.hpp @@ -1,5 +1,4 @@ #pragma once -#include #include #include #include diff --git a/include/fc/network/udp_socket.hpp b/include/fc/network/udp_socket.hpp index 65d1107..f150178 100644 --- a/include/fc/network/udp_socket.hpp +++ b/include/fc/network/udp_socket.hpp @@ -1,5 +1,4 @@ #pragma once -#include #include #include diff --git a/include/fc/network/url.hpp b/include/fc/network/url.hpp index 314aa29..7ccde78 100644 --- a/include/fc/network/url.hpp +++ b/include/fc/network/url.hpp @@ -1,5 +1,4 @@ #pragma once -#include #include #include #include @@ -8,7 +7,7 @@ namespace fc { - typedef fc::optional ostring; + typedef fc::optional ostring; typedef fc::optional opath; typedef fc::optional ovariant_object; diff --git a/include/fc/noncopyable.hpp b/include/fc/noncopyable.hpp deleted file mode 100644 index 87fad6b..0000000 --- a/include/fc/noncopyable.hpp +++ /dev/null @@ -1,14 +0,0 @@ -#pragma once - -namespace fc -{ - class noncopyable - { - public: - noncopyable(){} - private: - noncopyable( const noncopyable& ) = delete; - noncopyable& operator=( const noncopyable& ) = delete; - }; -} - diff --git a/include/fc/optional.hpp b/include/fc/optional.hpp index bb760a5..df6e1f2 100644 --- a/include/fc/optional.hpp +++ b/include/fc/optional.hpp @@ -43,7 +43,7 @@ namespace fc { optional( optional&& o ) :_valid(false) { - if( o._valid ) new (ptr()) T( fc::move(*o) ); + if( o._valid ) new (ptr()) T( std::move(*o) ); _valid = o._valid; o.reset(); } @@ -71,7 +71,7 @@ namespace fc { optional( optional&& o ) :_valid(false) { - if( o._valid ) new (ptr()) T( fc::move(*o) ); + if( o._valid ) new (ptr()) T( std::move(*o) ); _valid = o._valid; o.reset(); } @@ -156,10 +156,10 @@ namespace fc { { if( _valid && o._valid ) { - ref() = fc::move(*o); + ref() = std::move(*o); o.reset(); } else if ( !_valid && o._valid ) { - *this = fc::move(*o); + *this = std::move(*o); } else if (_valid) { reset(); } @@ -173,10 +173,10 @@ namespace fc { { if( _valid && o._valid ) { - ref() = fc::move(*o); + ref() = std::move(*o); o.reset(); } else if ( !_valid && o._valid ) { - *this = fc::move(*o); + *this = std::move(*o); } else if (_valid) { reset(); } diff --git a/include/fc/reflect/reflect.hpp b/include/fc/reflect/reflect.hpp index 5a97a8e..a5122d9 100644 --- a/include/fc/reflect/reflect.hpp +++ b/include/fc/reflect/reflect.hpp @@ -6,6 +6,7 @@ * */ +#include #include #include #include @@ -126,7 +127,7 @@ void fc::reflector::visit( const Visitor& v ) { \ #define FC_REFLECT_ENUM_TO_STRING( r, enum_type, elem ) \ case enum_type::elem: return BOOST_PP_STRINGIZE(elem); #define FC_REFLECT_ENUM_TO_FC_STRING( r, enum_type, elem ) \ - case enum_type::elem: return fc::string(BOOST_PP_STRINGIZE(elem)); + case enum_type::elem: return std::string(BOOST_PP_STRINGIZE(elem)); #define FC_REFLECT_ENUM_FROM_STRING( r, enum_type, elem ) \ if( strcmp( s, BOOST_PP_STRINGIZE(elem) ) == 0 ) return enum_type::elem; @@ -149,13 +150,13 @@ template<> struct reflector { \ static const char* to_string(int64_t i) { \ return to_string(ENUM(i)); \ } \ - static fc::string to_fc_string(ENUM elem) { \ + static std::string to_fc_string(ENUM elem) { \ switch( elem ) { \ BOOST_PP_SEQ_FOR_EACH( FC_REFLECT_ENUM_TO_FC_STRING, ENUM, FIELDS ) \ } \ return fc::to_string(int64_t(elem)); \ } \ - static fc::string to_fc_string(int64_t i) { \ + static std::string to_fc_string(int64_t i) { \ return to_fc_string(ENUM(i)); \ } \ static ENUM from_int(int64_t i) { \ diff --git a/include/fc/reflect/typename.hpp b/include/fc/reflect/typename.hpp index e7758f0..e61f79b 100644 --- a/include/fc/reflect/typename.hpp +++ b/include/fc/reflect/typename.hpp @@ -3,13 +3,12 @@ #include #include #include +#include #include -#include #include #include -#include namespace fc { class value; @@ -30,8 +29,8 @@ namespace fc { template<> struct get_typename { static const char* name() { return "bool"; } }; template<> struct get_typename { static const char* name() { return "char"; } }; template<> struct get_typename { static const char* name() { return "char"; } }; - template<> struct get_typename { static const char* name() { return "string"; } }; template<> struct get_typename { static const char* name() { return "value"; } }; + template<> struct get_typename { static const char* name() { return "string"; } }; template<> struct get_typename { static const char* name() { return "fc::exception"; } }; template<> struct get_typename> { static const char* name() { return "std::vector"; } }; template struct get_typename> diff --git a/include/fc/reflect/variant.hpp b/include/fc/reflect/variant.hpp index 60dcea8..b47de30 100644 --- a/include/fc/reflect/variant.hpp +++ b/include/fc/reflect/variant.hpp @@ -71,7 +71,7 @@ namespace fc { mutable_variant_object mvo; fc::reflector::visit( to_variant_visitor( mvo, v, max_depth ) ); - vo = fc::move(mvo); + vo = std::move(mvo); } template static inline void from_variant( const fc::variant& v, T& o, uint32_t max_depth ) diff --git a/include/fc/rpc/api_connection.hpp b/include/fc/rpc/api_connection.hpp index 1345c45..7280871 100644 --- a/include/fc/rpc/api_connection.hpp +++ b/include/fc/rpc/api_connection.hpp @@ -2,7 +2,7 @@ #include #include #include -#include +#include #include #include #include @@ -202,7 +202,7 @@ namespace fc { std::weak_ptr _api_connection; - fc::any _api; + boost::any _api; std::map< std::string, uint32_t > _by_name; std::vector< std::function > _methods; }; // class generic_api diff --git a/include/fc/rpc/binary_api_connection.hpp b/include/fc/rpc/binary_api_connection.hpp deleted file mode 100644 index 9c9ce2f..0000000 --- a/include/fc/rpc/binary_api_connection.hpp +++ /dev/null @@ -1,532 +0,0 @@ -#pragma once -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -//#include - -namespace fc { - class binary_api_connection; - - namespace detail { - template - class callback_functor - { - public: - typedef typename std::function::result_type result_type; - - callback_functor( std::weak_ptr< fc::binary_api_connection > con, uint64_t id ) - :_callback_id(id),_binary_api_connection(con){} - - template - result_type operator()( Args... args )const; - - private: - uint64_t _callback_id; - std::weak_ptr< fc::binary_api_connection > _binary_api_connection; - }; - - template - std::function bind_first_arg( const std::function& f, Arg0 a0 ) - { - return [=]( Args... args ) { return f( a0, args... ); }; - } - template - R call_generic( const std::function& f, variants::const_iterator a0, variants::const_iterator e ) - { - return f(); - } - - template - R call_generic( const std::function& f, variants::const_iterator a0, variants::const_iterator e ) - { - FC_ASSERT( a0 != e ); - return call_generic( bind_first_arg( f, a0->as< typename std::decay::type >() ), a0+1, e ); - } - - template - std::function to_generic( const std::function& f ) - { - return [=]( const variants& args ) { - return variant( call_generic( f, args.begin(), args.end() ) ); - }; - } - - template - std::function to_generic( const std::function& f ) - { - return [=]( const variants& args ) { - call_generic( f, args.begin(), args.end() ); - return variant(); - }; - } - - /** - * If api is returned from a remote method, the API is eagerly bound to api of - * the correct type in api_visitor::from_variant(). This binding [1] needs a reference - * to the binary_api_connection, which is made available to from_variant() as a parameter. - * - * However, in the case of a remote method which returns api_base which can subsequently - * be cast by the caller with as, we need to keep track of the connection because - * the binding is done later (when the client code actually calls as). - * - * [1] The binding actually happens in get_remote_api(). - */ - class any_api : public api_base - { - public: - any_api( api_id_type api_id, const std::shared_ptr& con ) - : _api_id(api_id), _binary_api_connection(con) {} - - virtual uint64_t get_handle()const override - { return _api_id; } - - virtual api_id_type register_api( binary_api_connection& conn )const override - { FC_ASSERT( false ); return api_id_type(); } - - api_id_type _api_id; - std::weak_ptr _binary_api_connection; - }; - - } // namespace detail - - class generic_api - { - public: - template - generic_api( const Api& a, const std::shared_ptr& c ); - - generic_api( const generic_api& cpy ) = delete; - - vector call( const string& name, const vector& args ) - { - auto itr = _by_name.find(name); - FC_ASSERT( itr != _by_name.end(), "no method with name '${name}'", ("name",name)("api",_by_name) ); - return call( itr->second, args ); - } - - vector call( uint32_t method_id, const vector& args ) - { - FC_ASSERT( method_id < _methods.size() ); - return _methods[method_id](args); - } - - std::weak_ptr< fc::binary_api_connection > get_connection() - { - return _binary_api_connection; - } - - std::vector get_method_names()const - { - std::vector result; - result.reserve( _by_name.size() ); - for( auto& m : _by_name ) result.push_back(m.first); - return result; - } - - private: - friend struct api_visitor; - - template - std::function bind_first_arg( const std::function& f, Arg0 a0 )const - { - return [=]( Args... args ) { return f( a0, args... ); }; - } - - template - R call_generic( const std::function& f, datastream& ds )const - { - return f(); - } - - template - R call_generic( const std::function,Args...)>& f, datastream& ds ) - { - uint64_t callback_id = 0; - fc::raw::unpack( ds, callback_id ); - detail::callback_functor arg0( get_connection(), callback_id ); - return call_generic( this->bind_first_arg,Args...>( f, std::function(arg0) ), ds ); - } - template - R call_generic( const std::function&,Args...)>& f, fc::datastream& ds ) - { - uint64_t callback_id = 0; - fc::raw::unpack( ds, callback_id ); - detail::callback_functor arg0( get_connection(), callback_id ); - return call_generic( this->bind_first_arg&,Args...>( f, arg0 ), ds ); - } - - template - R call_generic( const std::function& f, fc::datastream& ds ) - { - std::decay::type a0; - fc::raw::unpack( ds, a0 ); - return call_generic( this->bind_first_arg( f, a0 ), ds ); - } - - struct api_visitor - { - api_visitor( generic_api& a, const std::weak_ptr& s ):api(a),_api_con(s){ } - - template - std::function to_generic( const std::function(Args...)>& f )const; - - template - std::function to_generic( const std::function>(Args...)>& f )const; - - template - std::function to_generic( const std::function& f )const; - - template - std::function to_generic( const std::function& f )const; - - template - std::function to_generic( const std::function& f )const; - - template - void operator()( const char* name, std::function& memb )const { - api._methods.emplace_back( to_generic( memb ) ); - api._by_name[name] = api._methods.size() - 1; - } - - generic_api& api; - const std::weak_ptr& _api_con; - }; - - - std::weak_ptr _binary_api_connection; - fc::any _api; - std::map< std::string, uint32_t > _by_name; - std::vector< std::function(const vector&)> > _methods; - }; // class generic_api - - - - class binary_api_connection : public std::enable_shared_from_this - { - public: - typedef std::vector params_type; - typedef std::vector result_type; - - binary_api_connection(){} - virtual ~binary_api_connection(){}; - - - template - api get_remote_api( api_id_type api_id = 0 ) - { - api result; - result->visit( api_visitor( api_id, this->shared_from_this() ) ); - return result; - } - - /** makes calls to the remote server */ - virtual result_type send_call( api_id_type api_id, string method_name, params_type args = params_type() ) = 0; - virtual result_type send_callback( uint64_t callback_id, params_type args = params_type() ) = 0; - virtual void send_notice( uint64_t callback_id, params_type args = params_type() ) = 0; - - result_type receive_call( api_id_type api_id, const string& method_name, const params_type& args = params_type() )const - { - FC_ASSERT( _local_apis.size() > api_id ); - return _local_apis[api_id]->call( method_name, args ); - } - result_type receive_callback( uint64_t callback_id, const params_type& args = params_type() )const - { - FC_ASSERT( _local_callbacks.size() > callback_id ); - return _local_callbacks[callback_id]( args ); - } - void receive_notice( uint64_t callback_id, const params_type& args = params_type() )const - { - FC_ASSERT( _local_callbacks.size() > callback_id ); - _local_callbacks[callback_id]( args ); - } - - template - api_id_type register_api( const Interface& a ) - { - auto handle = a.get_handle(); - auto itr = _handle_to_id.find(handle); - if( itr != _handle_to_id.end() ) return itr->second; - - _local_apis.push_back( std::unique_ptr( new generic_api(a, shared_from_this() ) ) ); - _handle_to_id[handle] = _local_apis.size() - 1; - return _local_apis.size() - 1; - } - - template - uint64_t register_callback( const std::function& cb ) - { - _local_callbacks.push_back( detail::to_generic( cb ) ); - return _local_callbacks.size() - 1; - } - - std::vector get_method_names( api_id_type local_api_id = 0 )const { return _local_apis[local_api_id]->get_method_names(); } - - fc::signal closed; - private: - std::vector< std::unique_ptr > _local_apis; - std::map< uint64_t, api_id_type > _handle_to_id; - std::vector< std::function > _local_callbacks; - - - struct api_visitor - { - uint32_t _api_id; - std::shared_ptr _connection; - - api_visitor( uint32_t api_id, std::shared_ptr con ) - :_api_id(api_id),_connection(std::move(con)) - { - } - - api_visitor() = delete; - - template - static Result from_vector( const vector& v, Result*, const std::shared_ptr& ) - { - return fc::raw::unpack( v ); - } - - template - static fc::api from_vector( const vector& v, - fc::api* /*used for template deduction*/, - const std::shared_ptr& con - ) - { - return con->get_remote_api( fc::raw::unpack( v ) ); - } - - static fc::api_ptr from_vector( - const vector& v, - fc::api_ptr* /* used for template deduction */, - const std::shared_ptr& con - ) - { - return fc::api_ptr( new detail::any_api( fc::raw::unpack(v), con ) ); - } - - template - static result_type convert_callbacks( const std::shared_ptr&, const T& v ) - { - return fc::raw::pack(v); - } - - template - static result_type convert_callbacks( const std::shared_ptr& con, const std::function& v ) - { - return con->register_callback( v ); - } - - template - void operator()( const char* name, std::function& memb )const - { - auto con = _connection; - auto api_id = _api_id; - memb = [con,api_id,name]( Args... args ) { - auto var_result = con->send_call( api_id, name, { convert_callbacks(con,args)...} ); - return from_vector( var_result, (Result*)nullptr, con ); - }; - } - template - void operator()( const char* name, std::function& memb )const - { - auto con = _connection; - auto api_id = _api_id; - memb = [con,api_id,name]( Args... args ) { - con->send_call( api_id, name, { convert_callbacks(con,args)...} ); - }; - } - }; - }; - - class local_binary_api_connection : public binary_api_connection - { - public: - /** makes calls to the remote server */ - virtual result_type send_call( api_id_type api_id, string method_name, params_type args = params_type() ) override - { - FC_ASSERT( _remote_connection ); - return _remote_connection->receive_call( api_id, method_name, std::move(args) ); - } - virtual result_type send_callback( uint64_t callback_id, params_type args = params_type() ) override - { - FC_ASSERT( _remote_connection ); - return _remote_connection->receive_callback( callback_id, args ); - } - virtual void send_notice( uint64_t callback_id, params_type args = params_type() ) override - { - FC_ASSERT( _remote_connection ); - _remote_connection->receive_notice( callback_id, args ); - } - - - void set_remote_connection( const std::shared_ptr& rc ) - { - FC_ASSERT( !_remote_connection ); - FC_ASSERT( rc != this->shared_from_this() ); - _remote_connection = rc; - } - const std::shared_ptr& remote_connection()const { return _remote_connection; } - - std::shared_ptr _remote_connection; - }; - - template - generic_api::generic_api( const Api& a, const std::shared_ptr& c ) - :_binary_api_connection(c),_api(a) - { - boost::any_cast(a)->visit( api_visitor( *this, c ) ); - } - - template - std::function generic_api::api_visitor::to_generic( - const std::function(Args...)>& f )const - { - auto api_con = _api_con; - auto gapi = &api; - return [=]( const params_type& args ) { - auto con = api_con.lock(); - FC_ASSERT( con, "not connected" ); - - fc::raw::datastream ds( args.data(), args.size() ); - auto api_result = gapi->call_generic( f, args ); - return con->register_api( api_result ); - }; - } - template - std::function generic_api::api_visitor::to_generic( - const std::function>(Args...)>& f )const - { - auto api_con = _api_con; - auto gapi = &api; - return [=]( const params_type& args )-> fc::variant { - auto con = api_con.lock(); - FC_ASSERT( con, "not connected" ); - - fc::raw::datastream ds( args.data(), args.size() ); - auto api_result = gapi->call_generic( f, ds ); - if( api_result ) - return con->register_api( *api_result ); - return result_type(); - }; - } - - template - std::function generic_api::api_visitor::to_generic( - const std::function& f )const - { - auto api_con = _api_con; - auto gapi = &api; - return [=]( const variants& args ) -> fc::variant { - auto con = api_con.lock(); - FC_ASSERT( con, "not connected" ); - - fc::raw::datastream ds( args.data(), args.size() ); - auto api_result = gapi->call_generic( f, ds ); - if( !api_result ) - return result_type(); - return api_result->register_api( *con ); - }; - } - - template - std::function generic_api::api_visitor::to_generic( const std::function& f )const - { - generic_api* gapi = &api; - return [f,gapi]( const params_type& args ) { - fc::raw::datastream ds( args.data(), args.size() ); - return fc::raw::pack(gapi->call_generic( f, ds )); - }; - } - - template - std::function generic_api::api_visitor::to_generic( const std::function& f )const - { - generic_api* gapi = &api; - return [f,gapi]( const params_type& args ) { - fc::raw::datastream ds( args.data(), args.size() ); - gapi->call_generic( f, ds ); - return result_type(); - }; - } - - /** - * It is slightly unclean tight coupling to have this method in the api class. - * It breaks encapsulation by requiring an api class method to have a pointer - * to an binary_api_connection. The reason this is necessary is we have a goal of being - * able to call register_api() on an api through its base class api_base. But - * register_api() must know the template parameters! - * - * The only reasonable way to achieve the goal is to implement register_api() - * as a method in api (which obviously knows the template parameter T), - * then make the implementation accessible through the base class (by making - * it a pure virtual method in the base class which is overridden by the subclass's - * implementation). - */ - template< typename Interface, typename Transform > - api_id_type api< Interface, Transform >::register_api( binary_api_connection& conn )const - { - return conn.register_api( *this ); - } - - template< typename T > - api api_base::as() - { - // TODO: this method should probably be const (if it is not too hard) - api* maybe_requested_type = dynamic_cast< api* >(this); - if( maybe_requested_type != nullptr ) - return *maybe_requested_type; - - detail::any_api* maybe_any = dynamic_cast< detail::any_api* >(this); - FC_ASSERT( maybe_any != nullptr ); - std::shared_ptr< binary_api_connection > api_conn = maybe_any->_binary_api_connection.lock(); - FC_ASSERT( api_conn ); - return api_conn->get_remote_api( maybe_any->_api_id ); - } - - namespace detail { - template - template - typename callback_functor::result_type callback_functor::operator()( Args... args )const - { - std::shared_ptr< fc::binary_api_connection > locked = _binary_api_connection.lock(); - // TODO: make new exception type for this instead of recycling eof_exception - if( !locked ) - throw fc::eof_exception(); - - /// TODO------------->>> pack args... - locked->send_callback( _callback_id, fc::raw::pack( args... ) ).template as< result_type >(); - } - - - template - class callback_functor - { - public: - typedef void result_type; - - callback_functor( std::weak_ptr< fc::binary_api_connection > con, uint64_t id ) - :_callback_id(id),_binary_api_connection(con){} - - void operator()( Args... args )const - { - std::shared_ptr< fc::binary_api_connection > locked = _binary_api_connection.lock(); - // TODO: make new exception type for this instead of recycling eof_exception - if( !locked ) - throw fc::eof_exception(); - locked->send_notice( _callback_id, fc::variants{ args... } ); - } - - private: - uint64_t _callback_id; - std::weak_ptr< fc::binary_api_connection > _binary_api_connection; - }; - } // namespace detail - -} // fc diff --git a/include/fc/rpc/bstate.hpp b/include/fc/rpc/bstate.hpp index b7c74b7..8b398c4 100644 --- a/include/fc/rpc/bstate.hpp +++ b/include/fc/rpc/bstate.hpp @@ -32,8 +32,8 @@ namespace fc { namespace rpc { typedef std::function method; ~bstate(); - void add_method( const fc::string& name, method m ); - void remove_method( const fc::string& name ); + void add_method( const std::string& name, method m ); + void remove_method( const std::string& name ); result_type local_call( const string& method_name, const params_type& args ); void handle_reply( const bresponse& response ); diff --git a/include/fc/rpc/cli.hpp b/include/fc/rpc/cli.hpp index 00714a8..1acfb42 100644 --- a/include/fc/rpc/cli.hpp +++ b/include/fc/rpc/cli.hpp @@ -28,7 +28,7 @@ namespace fc { namespace rpc { void wait(); void format_result( const string& method, std::function formatter); - virtual void getline( const fc::string& prompt, fc::string& line ); + virtual void getline( const std::string& prompt, std::string& line ); void set_prompt( const string& prompt ); diff --git a/include/fc/rpc/json_connection.hpp b/include/fc/rpc/json_connection.hpp index af76e89..0208173 100644 --- a/include/fc/rpc/json_connection.hpp +++ b/include/fc/rpc/json_connection.hpp @@ -44,57 +44,57 @@ namespace fc { namespace rpc { * to call them. */ ///@{ - void add_method( const fc::string& name, method ); - void add_named_param_method( const fc::string& name, named_param_method ); - void remove_method( const fc::string& name ); + void add_method( const std::string& name, method ); + void add_named_param_method( const std::string& name, named_param_method ); + void remove_method( const std::string& name ); //@} /** * @name client interface */ ///@{ - void notice( const fc::string& method ); - void notice( const fc::string& method, const variants& args ); - void notice( const fc::string& method, const variant_object& named_args ); + void notice( const std::string& method ); + void notice( const std::string& method, const variants& args ); + void notice( const std::string& method, const variant_object& named_args ); /// args will be handled as named params - future async_call( const fc::string& method, + future async_call( const std::string& method, const variant_object& args ); - future async_call( const fc::string& method, mutable_variant_object args ); + future async_call( const std::string& method, mutable_variant_object args ); /// Sending in an array of variants will be handled as positional arguments - future async_call( const fc::string& method, + future async_call( const std::string& method, const variants& args ); - future async_call( const fc::string& method ); + future async_call( const std::string& method ); - future async_call( const fc::string& method, + future async_call( const std::string& method, const variant& a1 ); - future async_call( const fc::string& method, + future async_call( const std::string& method, const variant& a1, const variant& a2 ); - future async_call( const fc::string& method, + future async_call( const std::string& method, const variant& a1, const variant& a2, const variant& a3 ); - future async_call( const fc::string& method, + future async_call( const std::string& method, const variant& a1, const variant& a2, const variant& a3, const variant& a4 ); - future async_call( const fc::string& method, + future async_call( const std::string& method, const variant& a1, const variant& a2, const variant& a3, const variant& a4, const variant& a5 ); - future async_call( const fc::string& method, + future async_call( const std::string& method, const variant& a1, const variant& a2, const variant& a3, @@ -102,7 +102,7 @@ namespace fc { namespace rpc { const variant& a5, const variant& a6 ); - future async_call( const fc::string& method, + future async_call( const std::string& method, const variant& a1, const variant& a2, const variant& a3, @@ -112,7 +112,7 @@ namespace fc { namespace rpc { const variant& a7 ); - future async_call( const fc::string& method, + future async_call( const std::string& method, const variant& a1, const variant& a2, const variant& a3, @@ -122,7 +122,7 @@ namespace fc { namespace rpc { const variant& a7, const variant& a8 ); - future async_call( const fc::string& method, + future async_call( const std::string& method, const variant& a1, const variant& a2, const variant& a3, @@ -133,7 +133,7 @@ namespace fc { namespace rpc { const variant& a8, const variant& a9 ); - future async_call( const fc::string& method, + future async_call( const std::string& method, const variant& a1, const variant& a2, const variant& a3, @@ -147,7 +147,7 @@ namespace fc { namespace rpc { ); template - Result call( const fc::string& method, + Result call( const std::string& method, const variants& args, microseconds timeout = microseconds::maximum()) { @@ -155,7 +155,7 @@ namespace fc { namespace rpc { } template - Result call( const fc::string& method, + Result call( const std::string& method, const variant& a1, const variant& a2, const variant& a3, @@ -165,7 +165,7 @@ namespace fc { namespace rpc { } template - Result call( const fc::string& method, + Result call( const std::string& method, const variant& a1, const variant& a2, const variant& a3, @@ -176,7 +176,7 @@ namespace fc { namespace rpc { } template - Result call( const fc::string& method, + Result call( const std::string& method, const variant& a1, const variant& a2, const variant& a3, @@ -188,7 +188,7 @@ namespace fc { namespace rpc { } template - Result call( const fc::string& method, + Result call( const std::string& method, const variant& a1, const variant& a2, const variant& a3, @@ -200,7 +200,7 @@ namespace fc { namespace rpc { return async_call( method, a1, a2, a3, a4, a5, a6).wait(timeout).as(); } template - Result call( const fc::string& method, + Result call( const std::string& method, const variant& a1, const variant& a2, const variant& a3, @@ -214,7 +214,7 @@ namespace fc { namespace rpc { } template - Result call( const fc::string& method, + Result call( const std::string& method, const variant& a1, const variant& a2, const variant& a3, @@ -229,7 +229,7 @@ namespace fc { namespace rpc { } template - Result call( const fc::string& method, + Result call( const std::string& method, const variant& a1, const variant& a2, const variant& a3, @@ -245,7 +245,7 @@ namespace fc { namespace rpc { } template - Result call( const fc::string& method, + Result call( const std::string& method, const variant& a1, const variant& a2, const variant& a3, @@ -262,7 +262,7 @@ namespace fc { namespace rpc { } template - Result call( const fc::string& method, + Result call( const std::string& method, const variant& a1, const variant& a2, microseconds timeout = microseconds::maximum()) @@ -271,7 +271,7 @@ namespace fc { namespace rpc { } template - Result call( const fc::string& method, + Result call( const std::string& method, const variant& a1, microseconds timeout = microseconds::maximum()) { @@ -279,29 +279,29 @@ namespace fc { namespace rpc { } template - Result call( const fc::string& method, + Result call( const std::string& method, variant_object a1, microseconds timeout = microseconds::maximum()) { - return async_call( method, fc::move(a1) ).wait(timeout).as(); + return async_call( method, std::move(a1) ).wait(timeout).as(); } template - Result call( const fc::string& method, + Result call( const std::string& method, mutable_variant_object a1, microseconds timeout = microseconds::maximum()) { - return async_call( method, variant_object( fc::move(a1) ) ).wait(timeout).as(); + return async_call( method, variant_object( std::move(a1) ) ).wait(timeout).as(); } template - Result call( const fc::string& method, microseconds timeout = microseconds::maximum() ) + Result call( const std::string& method, microseconds timeout = microseconds::maximum() ) { return async_call( method ).wait(timeout).as(); } /// Sending in a variant_object will be issued as named parameters - variant call( const fc::string& method, const variant_object& named_args ); + variant call( const std::string& method, const variant_object& named_args ); ///@} protected: diff --git a/include/fc/rpc/state.hpp b/include/fc/rpc/state.hpp index e031530..5d6f618 100644 --- a/include/fc/rpc/state.hpp +++ b/include/fc/rpc/state.hpp @@ -26,7 +26,7 @@ namespace fc { namespace rpc { response( int64_t i, fc::variant r, string j ):id(i),jsonrpc(j),result(r){} response( int64_t i, error_object r, string j ):id(i),jsonrpc(j),error(r){} int64_t id = 0; - optional jsonrpc; + optional jsonrpc; optional result; optional error; }; @@ -37,8 +37,8 @@ namespace fc { namespace rpc { typedef std::function method; ~state(); - void add_method( const fc::string& name, method m ); - void remove_method( const fc::string& name ); + void add_method( const std::string& name, method m ); + void remove_method( const std::string& name ); variant local_call( const string& method_name, const variants& args ); void handle_reply( const response& response ); diff --git a/include/fc/rpc/variant_connection.hpp b/include/fc/rpc/variant_connection.hpp deleted file mode 100644 index 93cb29b..0000000 --- a/include/fc/rpc/variant_connection.hpp +++ /dev/null @@ -1,140 +0,0 @@ -#pragma once -#include -#include -#include -#include -#include - -namespace fc { namespace rpc { - - namespace detail { class variant_connection_impl; } - - /** - * @brief Implements JSON-RPC 2.0 over a set of io streams - * - * Each JSON RPC message is expected to be on its own line, violators - * will be prosecuted to the fullest extent of the law. - */ - class variant_connection - { - public: - typedef std::function method; - typedef std::function named_param_method; - - variant_connection( fc::variant_stream::ptr in, fc::variant_stream::ptr out ); - ~variant_connection(); - - /** - * Starts processing messages from input - */ - future exec(); - - logger get_logger()const; - void set_logger( const logger& l ); - - /** - * @name server interface - * - * Adding methods to the interface allows the remote side - * to call them. - */ - ///@{ - void add_method( const fc::string& name, method ); - void add_named_param_method( const fc::string& name, named_param_method ); - void remove_method( const fc::string& name ); - //@} - - /** - * @name client interface - */ - ///@{ - void notice( const fc::string& method ); - void notice( const fc::string& method, const variants& args ); - void notice( const fc::string& method, const variant_object& named_args ); - - /// args will be handled as named params - future async_call( const fc::string& method, - const variant_object& args ); - - future async_call( const fc::string& method, mutable_variant_object args ); - - /// Sending in an array of variants will be handled as positional arguments - future async_call( const fc::string& method, - const variants& args ); - - future async_call( const fc::string& method ); - - future async_call( const fc::string& method, - const variant& a1 ); - - future async_call( const fc::string& method, - const variant& a1, - const variant& a2 ); - - future async_call( const fc::string& method, - const variant& a1, - const variant& a2, - const variant& a3 ); - - template - Result call( const fc::string& method, - const variant& a1, - const variant& a2, - const variant& a3, - microseconds timeout = microseconds::maximum()) - { - return async_call( method, a1, a2, a3 ).wait(timeout).as(); - } - - template - Result call( const fc::string& method, - const variant& a1, - const variant& a2, - microseconds timeout = microseconds::maximum()) - { - return async_call( method, a1, a2 ).wait(timeout).as(); - } - - template - Result call( const fc::string& method, - const variant& a1, - microseconds timeout = microseconds::maximum()) - { - return async_call( method, a1 ).wait(timeout).as(); - } - - template - Result call( const fc::string& method, - variant_object a1, - microseconds timeout = microseconds::maximum()) - { - return async_call( method, fc::move(a1) ).wait(timeout).as(); - } - template - Result call( const fc::string& method, - mutable_variant_object a1, - microseconds timeout = microseconds::maximum()) - { - return async_call( method, variant_object( fc::move(a1) ) ).wait(timeout).as(); - } - - - template - Result call( const fc::string& method, microseconds timeout = microseconds::maximum() ) - { - return async_call( method ).wait(timeout).as(); - } - - /// Sending in a variant_object will be issued as named parameters - variant call( const fc::string& method, const variant_object& named_args ); - ///@} - - private: - std::unique_ptr my; - }; - typedef std::shared_ptr variant_connection_ptr; - -}} // fc::rpc - - - diff --git a/include/fc/rpc/variant_stream.hpp b/include/fc/rpc/variant_stream.hpp deleted file mode 100644 index 585b776..0000000 --- a/include/fc/rpc/variant_stream.hpp +++ /dev/null @@ -1,36 +0,0 @@ -#pragma once - -namespace fc -{ - - /** - * Thread-safe, circular buffer for passing variants - * between threads. - */ - class variant_stream - { - public: - variant_stream( size_t s ); - ~variant_stream(); - - /** producer api */ - int64_t free(); // number of spaces available - int64_t claim( int64_t num ); - int64_t publish( int64_t pos ); - int64_t wait_free(); // wait for free space - - // producer/consumer api - variant& get( int64_t pos ); - - /** consumer api */ - int64_t begin(); // returns the first index ready to be read - int64_t end(); // returns the first index that cannot be read - int64_t wait(); // wait for variants to be posted - - private: - std::vector _variants; - uint64_t _read_pos; - uint64_t _write_pos; - }; - -} diff --git a/include/fc/scoped_exit.hpp b/include/fc/scoped_exit.hpp deleted file mode 100644 index 98ec16d..0000000 --- a/include/fc/scoped_exit.hpp +++ /dev/null @@ -1,32 +0,0 @@ -#pragma once - -namespace fc { - - template - class scoped_exit { - public: - template - scoped_exit( C&& c ):callback( std::forward(c) ){} - scoped_exit( scoped_exit&& mv ):callback( std::move( mv.callback ) ){} - - ~scoped_exit() { - try { callback(); } catch( ... ) {} - } - - scoped_exit& operator = ( scoped_exit&& mv ) { - callback = std::move(mv); - return *this; - } - private: - scoped_exit( const scoped_exit& ); - scoped_exit& operator=( const scoped_exit& ); - - Callback callback; - }; - - template - scoped_exit make_scoped_exit( Callback&& c ) { - return scoped_exit( std::forward(c) ); - } - -} diff --git a/include/fc/shared_ptr.hpp b/include/fc/shared_ptr.hpp index 60a2cd3..cd6a94c 100644 --- a/include/fc/shared_ptr.hpp +++ b/include/fc/shared_ptr.hpp @@ -1,5 +1,7 @@ #pragma once -#include + +#include +#include namespace fc { @@ -62,7 +64,7 @@ namespace fc { return *this; } shared_ptr& operator=(shared_ptr&& p ) { - fc_swap(_ptr,p._ptr); + std::swap(_ptr,p._ptr); return *this; } T& operator* ()const { return *_ptr; } diff --git a/include/fc/signal.hpp b/include/fc/signal.hpp deleted file mode 100644 index 73c2b7f..0000000 --- a/include/fc/signal.hpp +++ /dev/null @@ -1,130 +0,0 @@ -#pragma once -#include -#include -#include -#include -#include -#include -#ifdef emit -#undef emit -#endif - -namespace fc { - - template - class signal { - private: - typedef std::function func_type; - typedef std::vector> list_type; - public: - typedef void* connection_id_type; - - template - connection_id_type connect( Functor&& f ) { - fc::unique_lock lock(_mutex); - //auto c = new std::function( fc::forward(f) ); - _handlers.push_back( std::make_shared(f) ); - return reinterpret_cast(_handlers.back().get()); - } -#ifdef WIN32 - template - void emit( Arg&& arg ) { - list_type handlers = getHandlers(); - for( size_t i = 0; i < handlers.size(); ++i ) { - (*handlers[i])( fc::forward(arg) ); - } - } - void operator()() { - list_type handlers = getHandlers(); - for( size_t i = 0; i < handlers.size(); ++i ) { - (*handlers[i])(); - } - } - template - void operator()( Arg&& arg ) { - list_type handlers = getHandlers(); - for( size_t i = 0; i < handlers.size(); ++i ) { - (*handlers[i])( fc::forward(arg) ); - } - } - template - void emit( Arg&& arg, Arg2&& arg2 ) { - list_type handlers = getHandlers(); - for( size_t i = 0; i < handlers.size(); ++i ) { - (*handlers[i])( fc::forward(arg), fc::forward(arg2) ); - } - } - template - void operator()( Arg&& arg, Arg2&& arg2 ) { - list_type handlers = getHandlers(); - for( size_t i = 0; i < handlers.size(); ++i ) { - (*handlers[i])( fc::forward(arg), fc::forward(arg2) ); - } - } - template - void emit( Arg&& arg, Arg2&& arg2, Arg3&& arg3 ) { - list_type handlers = getHandlers(); - for( size_t i = 0; i < handlers.size(); ++i ) { - (*handlers[i])( fc::forward(arg), fc::forward(arg2), fc::forward(arg3) ); - } - } - template - void operator()( Arg&& arg, Arg2&& arg2, Arg3&& arg3 ) { - list_type handlers = getHandlers(); - for( size_t i = 0; i < handlers.size(); ++i ) { - (*handlers[i])( fc::forward(arg), fc::forward(arg2), fc::forward(arg3) ); - } - } -#else - template - void emit( Args&&... args ) { - list_type handlers = getHandlers(); - for( size_t i = 0; i < handlers.size(); ++i ) { - (*handlers[i])( fc::forward(args)... ); - } - } - template - void operator()( Args&&... args ) { - list_type handlers = getHandlers(); - for( size_t i = 0; i < handlers.size(); ++i ) { - (*handlers[i])( fc::forward(args)... ); - } - } -#endif - - void disconnect( connection_id_type cid ) { - fc::unique_lock lock(_mutex); - auto itr = _handlers.begin(); - while( itr != _handlers.end() ) { - if( reinterpret_cast(itr->get()) == cid ) { - _handlers.erase(itr); - } - ++itr; - } - } - signal() - { - _handlers.reserve(4); - } - //~signal() - //{ - // for( auto itr = _handlers.begin(); itr != _handlers.end(); ++itr ) - // { - // delete *itr; - // } - // _handlers.clear(); - //} - - private: - fc::mutex _mutex; - list_type _handlers; - - list_type getHandlers() - { - fc::unique_lock lock(_mutex); - list_type handlers(_handlers); - return handlers; - } - }; - -} diff --git a/include/fc/string.hpp b/include/fc/string.hpp index 13e10da..7fbe2e5 100644 --- a/include/fc/string.hpp +++ b/include/fc/string.hpp @@ -1,154 +1,32 @@ #pragma once -#include #include #include - -#ifndef USE_FC_STRING #include + namespace fc { - typedef std::string string; + using std::string; - int64_t to_int64( const fc::string& ); - uint64_t to_uint64( const fc::string& ); - double to_double( const fc::string& ); - fc::string to_string( double ); - fc::string to_string( uint64_t ); - fc::string to_string( int64_t ); - fc::string to_string( uint16_t ); + int64_t to_int64( const std::string& ); + uint64_t to_uint64( const std::string& ); + double to_double( const std::string& ); + std::string to_string( double ); + std::string to_string( uint64_t ); + std::string to_string( int64_t ); + std::string to_string( uint16_t ); std::string to_pretty_string( int64_t ); - inline fc::string to_string( int32_t v ) { return to_string( int64_t(v) ); } - inline fc::string to_string( uint32_t v ){ return to_string( uint64_t(v) ); } + inline std::string to_string( int32_t v ) { return to_string( int64_t(v) ); } + inline std::string to_string( uint32_t v ){ return to_string( uint64_t(v) ); } #ifdef __APPLE__ - inline fc::string to_string( size_t s) { return to_string(uint64_t(s)); } + inline std::string to_string( size_t s) { return to_string(uint64_t(s)); } #endif - typedef fc::optional ostring; + typedef fc::optional ostring; class variant_object; - fc::string format_string( const fc::string&, const variant_object&, uint32_t max_object_depth = 200 ); - fc::string trim( const fc::string& ); - fc::string to_lower( const fc::string& ); + std::string format_string( const std::string&, const variant_object&, uint32_t max_object_depth = 200 ); + std::string trim( const std::string& ); + std::string to_lower( const std::string& ); string trim_and_normalize_spaces( const string& s ); uint64_t parse_size( const string& s ); } - -#else - -/** - * There is debate about whether doing this is 'standard conforming', but - * it works everywhere and enables the purpose of this library which is to - * accelerate compiles while maintaining compatability. - */ -namespace std { - template - struct char_traits; - - template - class allocator; - - template - class basic_string; - - typedef basic_string, allocator > string; -} - - -namespace fc { - /** - * @brief wrapper on std::string - * - * Including results in 4000 lines of code - * that must be included to build your header. This - * class hides all of those details while maintaining - * compatability with std::string. Using fc::string - * instead of std::string can accelerate compile times - * 10x. - * - * The implementation of this class is std::string, this header simply - * accelerates compile times. fc::string is automatically convertable to / from - * std::string. - */ - class string { - public: - typedef char* iterator; - typedef const char* const_iterator; - enum { npos = size_t(-1) }; - // static const size_t npos;// = -1; - - string(); - string( const std::string& s ); - string( std::string&& s ); - string( const string& c ); - string( string&& c ); - string( const char* c ); - string( const char* c, int s ); - string( const_iterator b, const_iterator e ); - ~string(); - - operator std::string&(); - operator const std::string&()const; - - iterator begin(); - iterator end(); - - const_iterator begin()const; - const_iterator end()const; - - char& operator[](size_t idx); - const char& operator[](size_t idx)const; - - string& operator =( const string& c ); - string& operator =( string&& c ); - - void reserve( size_t ); - size_t size()const; - size_t find( char c, size_t pos = 0 )const; - size_t find(const fc::string& str, size_t pos = 0) const; - size_t find(const char* s, size_t pos = 0) const; - size_t rfind( char c, size_t pos = npos )const; - size_t rfind( const char* c, size_t pos = npos )const; - size_t rfind( const fc::string& c, size_t pos = npos )const; - size_t find_first_of (const fc::string& str, size_t pos = 0) const; - size_t find_first_of (const char* s, size_t pos = 0) const; - string& replace(size_t pos, size_t len, const fc::string& str); - string& replace(size_t pos, size_t len, const char* s); - - void resize( size_t s ); - void clear(); - - const char* c_str()const; - char* data(); - - bool operator == ( const char* s )const; - bool operator == ( const string& s )const; - bool operator != ( const string& s )const; - - friend bool operator < ( const string& a, const string& b ); - - string& operator+=( const string& s ); - string& operator+=( char c ); - - friend string operator + ( const string&, const string& ); - friend string operator + ( const string&, char c ); - - fc::string substr( size_t start, size_t len = fc::string::npos )const; - - private: - fc::fwd my; - }; - - int64_t to_int64( const fc::string& ); - uint64_t to_uint64( const fc::string& ); - double to_double( const fc::string& ); - fc::string to_string( double ); - fc::string to_string( uint64_t ); - fc::string to_string( int64_t ); - - typedef fc::optional ostring; - class variant_object; - fc::string format_string( const fc::string&, const variant_object& ); - -} // namespace fc - -#endif diff --git a/include/fc/thread/future.hpp b/include/fc/thread/future.hpp index 0d0e2e7..f0365ea 100644 --- a/include/fc/thread/future.hpp +++ b/include/fc/thread/future.hpp @@ -1,5 +1,4 @@ #pragma once -#include #include #include #include @@ -35,7 +34,7 @@ namespace fc { template class completion_handler_impl : public completion_handler { public: - completion_handler_impl( Functor&& f ):_func(fc::move(f)){} + completion_handler_impl( Functor&& f ):_func(std::move(f)){} completion_handler_impl( const Functor& f ):_func(f){} virtual void on_complete( const void* v, const fc::exception_ptr& e ) { @@ -47,7 +46,7 @@ namespace fc { template class completion_handler_impl : public completion_handler { public: - completion_handler_impl( Functor&& f ):_func(fc::move(f)){} + completion_handler_impl( Functor&& f ):_func(std::move(f)){} completion_handler_impl( const Functor& f ):_func(f){} virtual void on_complete( const void* v, const fc::exception_ptr& e ) { _func(e); @@ -110,7 +109,7 @@ namespace fc { typedef fc::shared_ptr< promise > ptr; promise( const char* desc FC_TASK_NAME_DEFAULT_ARG):promise_base(desc){} promise( const T& val ){ set_value(val); } - promise( T&& val ){ set_value(fc::move(val) ); } + promise( T&& val ){ set_value(std::move(val) ); } const T& wait(const microseconds& timeout = microseconds::maximum() ){ this->_wait( timeout ); @@ -127,7 +126,7 @@ namespace fc { } void set_value( T&& v ) { - result = fc::move(v); + result = std::move(v); _set_value(&*result); } @@ -186,12 +185,12 @@ namespace fc { class future { public: future( const fc::shared_ptr>& p ):m_prom(p){} - future( fc::shared_ptr>&& p ):m_prom(fc::move(p)){} + future( fc::shared_ptr>&& p ):m_prom(std::move(p)){} future(const future& f ) : m_prom(f.m_prom){} future(){} future& operator=(future&& f ) { - fc_swap(m_prom,f.m_prom); + std::swap(m_prom,f.m_prom); return *this; } @@ -259,12 +258,12 @@ namespace fc { class future { public: future( const fc::shared_ptr>& p ):m_prom(p){} - future( fc::shared_ptr>&& p ):m_prom(fc::move(p)){} + future( fc::shared_ptr>&& p ):m_prom(std::move(p)){} future(const future& f ) : m_prom(f.m_prom){} future(){} future& operator=(future&& f ) { - fc_swap(m_prom,f.m_prom); + std::swap(m_prom,f.m_prom); return *this; } diff --git a/include/fc/thread/task.hpp b/include/fc/thread/task.hpp index 6c79d71..987810b 100644 --- a/include/fc/thread/task.hpp +++ b/include/fc/thread/task.hpp @@ -1,7 +1,6 @@ #pragma once #include #include -#include #include namespace fc { @@ -103,7 +102,7 @@ namespace fc { } virtual void cancel(const char* reason FC_CANCELATION_REASON_DEFAULT_ARG) override { task_base::cancel(reason); } - aligned _functor; + alignas(double) char _functor[FunctorSize]; private: ~task(){} }; @@ -123,7 +122,7 @@ namespace fc { } virtual void cancel(const char* reason FC_CANCELATION_REASON_DEFAULT_ARG) override { task_base::cancel(reason); } - aligned _functor; + alignas(double) char _functor[FunctorSize]; private: ~task(){} }; diff --git a/include/fc/thread/thread.hpp b/include/fc/thread/thread.hpp index 282fc30..7a886fa 100644 --- a/include/fc/thread/thread.hpp +++ b/include/fc/thread/thread.hpp @@ -3,8 +3,6 @@ #define FC_CONTEXT_STACK_SIZE (2048*1024) #include -#include -#include namespace fc { class time_point; @@ -75,7 +73,7 @@ namespace fc { * @note debug info is more useful if you provide a description for your * async tasks and promises. */ - void debug( const fc::string& d ); + void debug( const std::string& d ); /** @@ -146,7 +144,7 @@ namespace fc { std::vector proms(2); proms[0] = fc::static_pointer_cast(f1.m_prom); proms[1] = fc::static_pointer_cast(f2.m_prom); - return wait_any_until(fc::move(proms), fc::time_point::now()+timeout_us ); + return wait_any_until(std::move(proms), fc::time_point::now()+timeout_us ); } private: thread( class thread_d* ); // parameter is ignored, will create a new thread_d diff --git a/include/fc/thread/wait_condition.hpp b/include/fc/thread/wait_condition.hpp deleted file mode 100644 index 5006f87..0000000 --- a/include/fc/thread/wait_condition.hpp +++ /dev/null @@ -1,76 +0,0 @@ -#pragma once -#include -#include -#include -#include - -namespace fc -{ - /** - * A thread-safe, fiber-aware condition variable that - * can be used to signal/wait on a certain condition between - * threads. - */ - template - class wait_condition - { - public: - wait_condition(const char* name) : _name(name) {} - - void wait( const microseconds& timeout = microseconds::maximum() ) - { - typename fc::promise::ptr p = new fc::promise(_name); - { synchronized( _prom_lock ) - _promises.push_back( p ); - } - p->wait(timeout); - } - - template - T wait( LockType& l, const microseconds& timeout = microseconds::maximum() ) - { - typename fc::promise::ptr p( new fc::promise(_name)); - { synchronized( _prom_lock ) - _promises.push_back( p ); - } - l.unlock(); - struct relocker { - LockType& _lock; - relocker(LockType& l) : _lock(l) {} - ~relocker() { _lock.lock(); } - } lock_on_exit(l); - return p->wait(timeout); - } - - void notify_one( const T& t=T()) - { - typename fc::promise::ptr prom; - { synchronized( _prom_lock ) - if( _promises.size() ) - { - prom = _promises.front(); - _promises.pop_front(); - } - } - - if( prom && prom->retain_count() > 1 ) - prom->set_value(t); - } - void notify_all(const T& t=T()) - { - std::deque::ptr> all; - { synchronized( _prom_lock ) - std::swap(all, _promises); - } - for( auto itr = all.begin(); itr != all.end(); ++itr ) - { - if( (*itr)->retain_count() > 1 ) - (*itr)->set_value(t); - } - } - private: - fc::spin_yield_lock _prom_lock; - std::deque::ptr> _promises; - const char *const _name; - }; -} diff --git a/include/fc/time.hpp b/include/fc/time.hpp index c78c0f3..7eba301 100644 --- a/include/fc/time.hpp +++ b/include/fc/time.hpp @@ -1,6 +1,6 @@ #pragma once #include -#include +#include #include #ifdef _MSC_VER @@ -48,8 +48,8 @@ namespace fc { static time_point maximum() { return time_point( microseconds::maximum() ); } static time_point min() { return time_point(); } - operator fc::string()const; - static time_point from_iso_string( const fc::string& s ); + operator std::string()const; + static time_point from_iso_string( const std::string& s ); const microseconds& time_since_epoch()const { return elapsed; } uint32_t sec_since_epoch()const { return elapsed.count() / 1000000; } @@ -112,11 +112,11 @@ namespace fc { friend microseconds operator - ( const time_point_sec& t, const time_point_sec& m ) { return time_point(t) - time_point(m); } friend microseconds operator - ( const time_point& t, const time_point_sec& m ) { return time_point(t) - time_point(m); } - fc::string to_non_delimited_iso_string()const; - fc::string to_iso_string()const; + std::string to_non_delimited_iso_string()const; + std::string to_iso_string()const; - operator fc::string()const; - static time_point_sec from_iso_string( const fc::string& s ); + operator std::string()const; + static time_point_sec from_iso_string( const std::string& s ); private: uint32_t utc_seconds; @@ -127,12 +127,12 @@ namespace fc { /** return a human-readable approximate time, relative to now() * e.g., "4 hours ago", "2 months ago", etc. */ - string get_approximate_relative_time_string(const time_point_sec& event_time, - const time_point_sec& relative_to_time = fc::time_point::now(), - const std::string& ago = " ago"); - string get_approximate_relative_time_string(const time_point& event_time, - const time_point& relative_to_time = fc::time_point::now(), - const std::string& ago = " ago"); + std::string get_approximate_relative_time_string(const time_point_sec& event_time, + const time_point_sec& relative_to_time = fc::time_point::now(), + const std::string& ago = " ago"); + std::string get_approximate_relative_time_string(const time_point& event_time, + const time_point& relative_to_time = fc::time_point::now(), + const std::string& ago = " ago"); } #include diff --git a/include/fc/tuple.hpp b/include/fc/tuple.hpp deleted file mode 100644 index 9fe9638..0000000 --- a/include/fc/tuple.hpp +++ /dev/null @@ -1,136 +0,0 @@ -#pragma once -#include -#include -#include -#include -#include -#include -#include -#include - -namespace fc { - - /** - * Provides a fast-compiling tuple that doesn't use fancy meta-programming - * techniques. It is limited to 4 parameters which is sufficient for most - * methods argument lists which is the primary use case for this tuple. Methods - * that require more than 4 parameters are probably better served by defining - * a struct. - * - * The members of the tuple are easily visited with a simple visitor functor - * of the form: - * @code - * struct visitor { - * template - * void operator()( MemberType& m ); - * - * template - * void operator()( const MemberType& m ); - * }; - * @endcode - template - struct tuple { - tuple(){} - enum size_enum { size = 4 }; - - template - tuple( AA&& aa, BB&& bb, CC&& cc, DD&& dd ) - :a( fc::forward(aa) ), - b( fc::forward(bb) ), - c( fc::forward(cc) ), - d( fc::forward
(dd) ) - {} - - template - void visit( V&& v ) { v(a); v(b); v(c); v(d); } - template - void visit( V&& v )const { v(a); v(b); v(c); v(d); } - - A a; - B b; - C c; - D d; - }; - */ - template struct tuple{}; - - template<> - struct tuple<> { - enum size_enum { size = 0 }; - template - void visit( V&& v)const{}; - }; - template - auto call_fused( Functor f, const tuple<>& t ) -> decltype( f( ) ) { - return f(); - } - - inline tuple<> make_tuple(){ return tuple<>(); } - - template - struct is_tuple { - typedef fc::false_type type; - }; - - #define RREF_PARAMS(z,n,data) BOOST_PP_CAT(AA,n)&& BOOST_PP_CAT(p,n) - #define ILIST_PARAMS(z,n,data) BOOST_PP_CAT(a,n)( fc::forward( BOOST_PP_CAT(p,n) ) ) - #define ILIST_PARAMS_COPY(z,n,data) BOOST_PP_CAT(a,n)( t.BOOST_PP_CAT(a,n) ) - #define VISIT_PARAMS(z,n,data) v(BOOST_PP_CAT(a,n)); - #define LIST_MEMBERS_ON(z,n,data) data.BOOST_PP_CAT(a,n) - #define DEDUCE_MEMBERS(z,n,data) typename fc::deduce::type - #define FORWARD_PARAMS(z,n,data) fc::forward(BOOST_PP_CAT(p,n)) - #define MEM_PARAMS(z,n,data) BOOST_PP_CAT(A,n) BOOST_PP_CAT(a,n); - #define TUPLE(z,n,unused) \ - template \ - struct tuple { \ - enum size_enum { size = n }; \ - template \ - explicit tuple( BOOST_PP_ENUM(n, RREF_PARAMS, unused ) )BOOST_PP_IF(n,:,BOOST_PP_EMPTY())BOOST_PP_ENUM( n, ILIST_PARAMS,unused){} \ - tuple( const tuple& t )BOOST_PP_IF(n,:,BOOST_PP_EMPTY())BOOST_PP_ENUM( n, ILIST_PARAMS_COPY,unused){} \ - tuple( tuple&& t )BOOST_PP_IF(n,:,BOOST_PP_EMPTY())BOOST_PP_ENUM( n, ILIST_PARAMS_COPY,unused){} \ - tuple(){}\ - template\ - void visit( V&& v ) { BOOST_PP_REPEAT(n,VISIT_PARAMS,a) }\ - template\ - void visit( V&& v )const { BOOST_PP_REPEAT(n,VISIT_PARAMS,a) }\ - BOOST_PP_REPEAT(n,MEM_PARAMS,a) \ - }; \ - template \ - tuple make_tuple( BOOST_PP_ENUM( n, RREF_PARAMS, unused) ) { \ - return tuple( BOOST_PP_ENUM( n, FORWARD_PARAMS,unused ) ); \ - } \ - template \ - auto call_fused( Functor f, tuple& t ) \ - -> decltype( f( BOOST_PP_ENUM( n, LIST_MEMBERS_ON, t) ) ) { \ - return f( BOOST_PP_ENUM( n, LIST_MEMBERS_ON, t) ); \ - } \ - template \ - auto call_fused( Functor f, const tuple& t ) \ - -> decltype( f( BOOST_PP_ENUM( n, LIST_MEMBERS_ON, t) ) ) { \ - return f( BOOST_PP_ENUM( n, LIST_MEMBERS_ON, t) ); \ - } \ - template \ - struct is_tuple > { \ - typedef fc::true_type type; \ - }; \ - template \ - struct deduce > { \ - typedef fc::tuple type; \ - }; - - BOOST_PP_REPEAT_FROM_TO( 1, 5, TUPLE, unused ) - - - #undef FORWARD_PARAMS - #undef DEDUCE_MEMBERS - #undef RREF_PARAMS - #undef LIST_MEMBERS_ON - #undef ILIST_PARAMS - #undef ILIST_PARAMS_COPY - #undef VISIT_PARAMS - #undef MEM_PARAMS - #undef TUPLE - - -} - diff --git a/include/fc/unique_ptr.hpp b/include/fc/unique_ptr.hpp deleted file mode 100644 index 609eff8..0000000 --- a/include/fc/unique_ptr.hpp +++ /dev/null @@ -1,60 +0,0 @@ -#pragma once -#include -#include - -namespace fc -{ - template - class unique_ptr - { - public: - typedef T* pointer; - - explicit unique_ptr( pointer t = nullptr ):_p(t){} - - unique_ptr( unique_ptr&& m ) - :_p(m._p){ m._p = nullptr; } - - ~unique_ptr() { delete _p; } - - operator bool()const { return _p != nullptr; } - friend bool operator==(const unique_ptr& p, nullptr_t) - { - return p._p == nullptr; - } - - friend bool operator!=(const unique_ptr& p, nullptr_t) - { - return p._p != nullptr; - } - - unique_ptr& operator=( nullptr_t ) - { - delete _p; _p = nullptr; - } - - unique_ptr& operator=( unique_ptr&& o ) - { - fc_swap( _p, o._p ); - return *this; - } - - pointer operator->()const { return _p; } - T& operator*()const { return *_p; } - - void reset( pointer v ) - { - delete _p; _p = v; - } - pointer release() - { - auto tmp = _p; - _p = nullptr; - return tmp; - } - - private: - pointer _p; - }; - -} diff --git a/include/fc/utility.hpp b/include/fc/utility.hpp index 0096ac5..e0e6371 100644 --- a/include/fc/utility.hpp +++ b/include/fc/utility.hpp @@ -19,19 +19,12 @@ namespace fc { using std::size_t; typedef decltype(nullptr) nullptr_t; - template struct remove_reference { typedef T type; }; - template struct remove_reference { typedef T type; }; - template struct remove_reference { typedef T type; }; - template struct deduce { typedef T type; }; template struct deduce { typedef T type; }; template struct deduce { typedef T type; }; template struct deduce { typedef T type; }; template struct deduce{ typedef T type; }; - template - typename fc::remove_reference::type&& move( T&& t ) { return static_cast::type&&>(t); } - template inline T&& forward( U&& u ) { return static_cast(u); } @@ -45,21 +38,4 @@ namespace fc { template struct is_class { typedef decltype(detail::is_class_helper(0)) type; enum value_enum { value = type::value }; }; -#ifdef min -#undef min -#endif - template - const T& min( const T& a, const T& b ) { return a < b ? a: b; } - } - // outside of namespace fc becuase of VC++ conflict with std::swap - template - void fc_swap( T& a, T& b ) { - T tmp = fc::move(a); - a = fc::move(b); - b = fc::move(tmp); - } - -#define LLCONST(constant) static_cast(constant##ll) -#define ULLCONST(constant) static_cast(constant##ull) - diff --git a/include/fc/variant.hpp b/include/fc/variant.hpp index 03b7eda..c98e796 100644 --- a/include/fc/variant.hpp +++ b/include/fc/variant.hpp @@ -11,8 +11,6 @@ #include // memset #include -#include -#include #include #include @@ -217,7 +215,7 @@ namespace fc variant( double val, uint32_t max_depth = 1 ); variant( bool val, uint32_t max_depth = 1 ); variant( blob val, uint32_t max_depth = 1 ); - variant( fc::string val, uint32_t max_depth = 1 ); + variant( std::string val, uint32_t max_depth = 1 ); variant( variant_object, uint32_t max_depth = 1 ); variant( mutable_variant_object, uint32_t max_depth = 1 ); variant( variants, uint32_t max_depth = 1 ); @@ -238,7 +236,7 @@ namespace fc virtual void handle( const uint64_t& v )const = 0; virtual void handle( const double& v )const = 0; virtual void handle( const bool& v )const = 0; - virtual void handle( const string& v )const = 0; + virtual void handle( const std::string& v )const = 0; virtual void handle( const variant_object& v)const = 0; virtual void handle( const variants& v)const = 0; }; @@ -277,10 +275,10 @@ namespace fc /** Convert's double, ints, bools, etc to a string * @throw if get_type() == array_type | get_type() == object_type */ - string as_string()const; + std::string as_string()const; /// @pre get_type() == string_type - const string& get_string()const; + const std::string& get_string()const; /// @throw if get_type() != array_type | null_type variants& get_array(); @@ -357,7 +355,7 @@ namespace fc typedef optional ovariant; /** @ingroup Serializable */ - void from_variant( const variant& var, string& vo, uint32_t max_depth = 1 ); + void from_variant( const variant& var, std::string& vo, uint32_t max_depth = 1 ); /** @ingroup Serializable */ void from_variant( const variant& var, variants& vo, uint32_t max_depth ); void from_variant( const variant& var, variant& vo, uint32_t max_depth ); diff --git a/include/fc/variant_object.hpp b/include/fc/variant_object.hpp index b516630..73edd26 100644 --- a/include/fc/variant_object.hpp +++ b/include/fc/variant_object.hpp @@ -1,7 +1,6 @@ #pragma once #include #include -#include namespace fc { diff --git a/include/fc/vector.hpp b/include/fc/vector.hpp deleted file mode 100644 index 29b3388..0000000 --- a/include/fc/vector.hpp +++ /dev/null @@ -1,2 +0,0 @@ -#pragma once -#include diff --git a/include/fc/vector_fwd.hpp b/include/fc/vector_fwd.hpp deleted file mode 100644 index a57fec7..0000000 --- a/include/fc/vector_fwd.hpp +++ /dev/null @@ -1,11 +0,0 @@ -#ifndef _FC_VECTOR_FWD_HPP_ -#define _FC_VECTOR_FWD_HPP_ -#if 0 -#include -#else -namespace fc { - template class vector; -}; -#endif - -#endif // _FC_VECTOR_FWD_HPP_ diff --git a/include/fc/wait_any.hpp b/include/fc/wait_any.hpp deleted file mode 100644 index c3d6207..0000000 --- a/include/fc/wait_any.hpp +++ /dev/null @@ -1,13 +0,0 @@ -#pragma once -#include -#include - -namespace fc { - template - int wait_any( fc::future& f1, fc::future& f2, const microseconds& timeout_us = microseconds::max() ) { - fc::vector p(2); - p[0] = static_pointer_cast(f1.promise()); - p[1] = static_pointer_cast(f2.promise()); - return wait( fc::move(p), timeout_us ); - } -} diff --git a/src/compress/zlib.cpp b/src/compress/zlib.cpp index dd9d23b..b883596 100644 --- a/src/compress/zlib.cpp +++ b/src/compress/zlib.cpp @@ -4,11 +4,11 @@ namespace fc { - string zlib_compress(const string& in) + std::string zlib_compress(const std::string& in) { size_t compressed_message_length; char* compressed_message = (char*)tdefl_compress_mem_to_heap(in.c_str(), in.size(), &compressed_message_length, TDEFL_WRITE_ZLIB_HEADER | TDEFL_DEFAULT_MAX_PROBES); - string result(compressed_message, compressed_message_length); + std::string result(compressed_message, compressed_message_length); free(compressed_message); return result; } diff --git a/src/crypto/base36.cpp b/src/crypto/base36.cpp index 5e3bd5b..c4a9d23 100644 --- a/src/crypto/base36.cpp +++ b/src/crypto/base36.cpp @@ -1,13 +1,14 @@ #include +#include #include #include #include namespace fc { - fc::string to_base36( const char* data, size_t len ) + std::string to_base36( const char* data, size_t len ) { - if( len == 0 ) return fc::string(); + if( len == 0 ) return std::string(); const char* src = data; int src_len = len; @@ -34,15 +35,15 @@ namespace fc while (len-- > 0 && *data++ == 0) { out[--pos] = '0'; } - return &out[pos]; //fc::string( &out[pos], out.size() - pos); + return &out[pos]; //std::string( &out[pos], out.size() - pos); } - fc::string to_base36( const std::vector& vec ) + std::string to_base36( const std::vector& vec ) { return to_base36( (const char*)vec.data(), vec.size() ); } - std::vector from_base36( const fc::string& b36 ) + std::vector from_base36( const std::string& b36 ) { if ( b36.empty() ) { std::vector empty; @@ -63,7 +64,7 @@ namespace fc value = value + (_36.exp(pos) * fc::bigint(10+*itr - 'A')); else { - wlog("unknown '${char}'", ("char",fc::string(&*itr,1)) ); + wlog("unknown '${char}'", ("char",std::string(&*itr,1)) ); } ++pos; } diff --git a/src/crypto/base58.cpp b/src/crypto/base58.cpp index 6cc7e58..929f387 100644 --- a/src/crypto/base58.cpp +++ b/src/crypto/base58.cpp @@ -22,7 +22,6 @@ #include #include -#include #include #include diff --git a/src/crypto/bigint.cpp b/src/crypto/bigint.cpp index 478f949..fd5a688 100644 --- a/src/crypto/bigint.cpp +++ b/src/crypto/bigint.cpp @@ -1,5 +1,4 @@ #include -#include #include #include #include @@ -145,7 +144,7 @@ namespace fc { BN_CTX* ctx = BN_CTX_new(); bigint tmp; BN_div( tmp.n, NULL, n, a.n, ctx ); - fc_swap( tmp.n, n ); + std::swap( tmp.n, n ); BN_CTX_free(ctx); return tmp; } @@ -190,7 +189,7 @@ namespace fc { bigint& bigint::operator = ( bigint&& a ) { if( &a == this ) return *this; - fc_swap( a.n, n ); + std::swap( a.n, n ); return *this; } bigint& bigint::operator = ( const bigint& a ) { @@ -199,7 +198,7 @@ namespace fc { BN_copy( n, a.n ); return *this; } - bigint::operator fc::string()const { + bigint::operator std::string()const { return BN_bn2dec(n); } diff --git a/src/crypto/elliptic_common.cpp b/src/crypto/elliptic_common.cpp index 7d8b6ed..1e74981 100644 --- a/src/crypto/elliptic_common.cpp +++ b/src/crypto/elliptic_common.cpp @@ -229,7 +229,7 @@ namespace fc { namespace ecc { return private_key( k ); } - static fc::string _to_base58( const extended_key_data& key ) + static std::string _to_base58( const extended_key_data& key ) { size_t buf_len = key.size() + 4; char *buffer = (char*)alloca(buf_len); @@ -239,7 +239,7 @@ namespace fc { namespace ecc { return fc::to_base58( buffer, buf_len ); } - static void _parse_extended_data( unsigned char* buffer, fc::string base58 ) + static void _parse_extended_data( unsigned char* buffer, std::string base58 ) { memset( buffer, 0, 78 ); std::vector decoded = fc::from_base58( base58 ); @@ -276,12 +276,12 @@ namespace fc { namespace ecc { return from_base58( _to_base58( data ) ); } - fc::string extended_public_key::str() const + std::string extended_public_key::str() const { return _to_base58( serialize_extended() ); } - extended_public_key extended_public_key::from_base58( const fc::string& base58 ) + extended_public_key extended_public_key::from_base58( const std::string& base58 ) { unsigned char buffer[78]; unsigned char* ptr = buffer; @@ -344,12 +344,12 @@ namespace fc { namespace ecc { return from_base58( _to_base58( data ) ); } - fc::string extended_private_key::str() const + std::string extended_private_key::str() const { return _to_base58( serialize_extended() ); } - extended_private_key extended_private_key::from_base58( const fc::string& base58 ) + extended_private_key extended_private_key::from_base58( const std::string& base58 ) { unsigned char buffer[78]; unsigned char* ptr = buffer; @@ -366,7 +366,7 @@ namespace fc { namespace ecc { return extended_private_key( private_key::regenerate(key), chain, cn, fp, d ); } - extended_private_key extended_private_key::generate_master( const fc::string& seed ) + extended_private_key extended_private_key::generate_master( const std::string& seed ) { return generate_master( seed.c_str(), seed.size() ); } diff --git a/src/crypto/hex.cpp b/src/crypto/hex.cpp index 67ef919..5a585bd 100644 --- a/src/crypto/hex.cpp +++ b/src/crypto/hex.cpp @@ -10,7 +10,7 @@ namespace fc { return c - 'a' + 10; if( c >= 'A' && c <= 'F' ) return c - 'A' + 10; - FC_THROW_EXCEPTION( exception, "Invalid hex character '${c}'", ("c", fc::string(&c,1) ) ); + FC_THROW_EXCEPTION( exception, "Invalid hex character '${c}'", ("c", std::string(&c,1) ) ); return 0; } @@ -24,8 +24,8 @@ namespace fc { return r; } - size_t from_hex( const fc::string& hex_str, char* out_data, size_t out_data_len ) { - fc::string::const_iterator i = hex_str.begin(); + size_t from_hex( const std::string& hex_str, char* out_data, size_t out_data_len ) { + std::string::const_iterator i = hex_str.begin(); uint8_t* out_pos = (uint8_t*)out_data; uint8_t* out_end = out_pos + out_data_len; while( i != hex_str.end() && out_end != out_pos ) { diff --git a/src/crypto/pke.cpp b/src/crypto/pke.cpp index 28cd60d..87ee25a 100644 --- a/src/crypto/pke.cpp +++ b/src/crypto/pke.cpp @@ -97,7 +97,7 @@ namespace fc { out.resize(rtn); return out; } - FC_THROW_EXCEPTION( exception, "openssl: ${message}", ("message",fc::string(ERR_error_string( ERR_get_error(),NULL))) ); + FC_THROW_EXCEPTION( exception, "openssl: ${message}", ("message",std::string(ERR_error_string( ERR_get_error(),NULL))) ); } bytes public_key::encrypt( const bytes& in )const @@ -113,7 +113,7 @@ namespace fc { out.resize(rtn); return out; } - FC_THROW_EXCEPTION( exception, "openssl: ${message}", ("message",fc::string(ERR_error_string( ERR_get_error(),NULL))) ); + FC_THROW_EXCEPTION( exception, "openssl: ${message}", ("message",std::string(ERR_error_string( ERR_get_error(),NULL))) ); } bytes public_key::decrypt( const bytes& in )const { @@ -127,7 +127,7 @@ namespace fc { out.resize(rtn); return out; } - FC_THROW_EXCEPTION( exception, "openssl: ${message}", ("message",fc::string(ERR_error_string( ERR_get_error(),NULL))) ); + FC_THROW_EXCEPTION( exception, "openssl: ${message}", ("message",std::string(ERR_error_string( ERR_get_error(),NULL))) ); } bytes public_key::serialize()const @@ -140,14 +140,14 @@ namespace fc { if( e != 1 ) { BIO_free(mem); - FC_THROW_EXCEPTION( exception, "openssl: ${message}", ("message",fc::string(ERR_error_string( ERR_get_error(),NULL))) ); + FC_THROW_EXCEPTION( exception, "openssl: ${message}", ("message",std::string(ERR_error_string( ERR_get_error(),NULL))) ); } char* dat; uint32_t l = BIO_get_mem_data( mem, &dat ); fc::stringstream ss( string( dat, l ) ); fc::stringstream key; - fc::string tmp; + std::string tmp; fc::getline( ss, tmp ); fc::getline( ss, tmp ); while( tmp.size() && tmp[0] != '-' ) @@ -210,7 +210,7 @@ namespace fc { if( 1 != RSA_sign( NID_sha1, (uint8_t*)&digest, 20, (unsigned char*)&sig, &slen, my->rsa ) ) { - FC_THROW_EXCEPTION( exception, "rsa sign failed with ${message}", ("message",fc::string(ERR_error_string( ERR_get_error(),NULL))) ); + FC_THROW_EXCEPTION( exception, "rsa sign failed with ${message}", ("message",std::string(ERR_error_string( ERR_get_error(),NULL))) ); } } @@ -224,7 +224,7 @@ namespace fc { if( 1 != RSA_sign( NID_sha1, (uint8_t*)digest.data(), 20, (unsigned char*)sig.data(), &slen, my->rsa ) ) { - FC_THROW_EXCEPTION( exception, "rsa sign failed with ${message}", ("message",fc::string(ERR_error_string( ERR_get_error(),NULL))) ); + FC_THROW_EXCEPTION( exception, "rsa sign failed with ${message}", ("message",std::string(ERR_error_string( ERR_get_error(),NULL))) ); } return sig; } @@ -238,7 +238,7 @@ namespace fc { if( 1 != RSA_sign( NID_sha256, (uint8_t*)digest.data(), 32, (unsigned char*)sig.data(), &slen, my->rsa ) ) { - FC_THROW_EXCEPTION( exception, "rsa sign failed with ${message}", ("message",fc::string(ERR_error_string( ERR_get_error(),NULL))) ); + FC_THROW_EXCEPTION( exception, "rsa sign failed with ${message}", ("message",std::string(ERR_error_string( ERR_get_error(),NULL))) ); } return sig; } @@ -302,7 +302,7 @@ namespace fc { if( e != 1 ) { BIO_free(mem); - FC_THROW_EXCEPTION( exception, "Error writing private key, ${message}", ("message",fc::string(ERR_error_string( ERR_get_error(),NULL))) ); + FC_THROW_EXCEPTION( exception, "Error writing private key, ${message}", ("message",std::string(ERR_error_string( ERR_get_error(),NULL))) ); } char* dat; uint32_t l = BIO_get_mem_data( mem, &dat ); diff --git a/src/crypto/ripemd160.cpp b/src/crypto/ripemd160.cpp index 3e96048..b76de34 100644 --- a/src/crypto/ripemd160.cpp +++ b/src/crypto/ripemd160.cpp @@ -108,7 +108,7 @@ bool operator == ( const ripemd160& h1, const ripemd160& h2 ) { std::vector ve = v.as< std::vector >( max_depth ); memset( &bi, char(0), sizeof(bi) ); if( ve.size() ) - memcpy( &bi, ve.data(), fc::min(ve.size(),sizeof(bi)) ); + memcpy( &bi, ve.data(), std::min(ve.size(),sizeof(bi)) ); } } // fc diff --git a/src/crypto/sha1.cpp b/src/crypto/sha1.cpp index f509f00..983edc4 100644 --- a/src/crypto/sha1.cpp +++ b/src/crypto/sha1.cpp @@ -92,7 +92,7 @@ bool operator == ( const sha1& h1, const sha1& h2 ) { std::vector ve = v.as< std::vector >( max_depth ); memset( &bi, char(0), sizeof(bi) ); if( ve.size() ) - memcpy( &bi, ve.data(), fc::min(ve.size(),sizeof(bi)) ); + memcpy( &bi, ve.data(), std::min(ve.size(),sizeof(bi)) ); } } // fc diff --git a/src/crypto/sha224.cpp b/src/crypto/sha224.cpp index 4015f90..b1096b6 100644 --- a/src/crypto/sha224.cpp +++ b/src/crypto/sha224.cpp @@ -88,7 +88,7 @@ namespace fc { std::vector ve = v.as< std::vector >( max_depth ); memset( &bi, char(0), sizeof(bi) ); if( ve.size() ) - memcpy( &bi, ve.data(), fc::min(ve.size(),sizeof(bi)) ); + memcpy( &bi, ve.data(), std::min(ve.size(),sizeof(bi)) ); } template<> diff --git a/src/crypto/sha256.cpp b/src/crypto/sha256.cpp index e27fd60..c3edd9b 100644 --- a/src/crypto/sha256.cpp +++ b/src/crypto/sha256.cpp @@ -202,7 +202,7 @@ namespace fc { std::vector ve = v.as< std::vector >( max_depth ); memset( &bi, char(0), sizeof(bi) ); if( ve.size() ) - memcpy( &bi, ve.data(), fc::min(ve.size(),sizeof(bi)) ); + memcpy( &bi, ve.data(), std::min(ve.size(),sizeof(bi)) ); } uint64_t hash64(const char* buf, size_t len) diff --git a/src/crypto/sha512.cpp b/src/crypto/sha512.cpp index 49bc8d9..4b82efe 100644 --- a/src/crypto/sha512.cpp +++ b/src/crypto/sha512.cpp @@ -94,7 +94,7 @@ namespace fc { std::vector ve = v.as< std::vector >( max_depth ); memset( &bi, char(0), sizeof(bi) ); if( ve.size() ) - memcpy( &bi, ve.data(), fc::min(ve.size(),sizeof(bi)) ); + memcpy( &bi, ve.data(), std::min(ve.size(),sizeof(bi)) ); } template<> diff --git a/src/exception.cpp b/src/exception.cpp index 1f84286..b957f2f 100644 --- a/src/exception.cpp +++ b/src/exception.cpp @@ -46,7 +46,7 @@ namespace fc my->_code = code; my->_what = what_value; my->_name = name_value; - my->_elog = fc::move(msgs); + my->_elog = std::move(msgs); } exception::exception( @@ -63,7 +63,7 @@ namespace fc } unhandled_exception::unhandled_exception( log_message&& m, std::exception_ptr e ) - :exception( fc::move(m) ) + :exception( std::move(m) ) { _inner = e; } @@ -73,7 +73,7 @@ namespace fc } unhandled_exception::unhandled_exception( log_messages m ) :exception() - { my->_elog = fc::move(m); } + { my->_elog = std::move(m); } std::exception_ptr unhandled_exception::get_inner_exception()const { return _inner; } @@ -109,13 +109,13 @@ namespace fc my->_code = code; my->_what = what_value; my->_name = name_value; - my->_elog.push_back( fc::move( msg ) ); + my->_elog.push_back( std::move( msg ) ); } exception::exception( const exception& c ) :my( new detail::exception_impl(*c.my) ) { } exception::exception( exception&& c ) - :my( fc::move(c.my) ){} + :my( std::move(c.my) ){} const char* exception::name()const throw() { return my->_name.c_str(); } const char* exception::what()const throw() { return my->_what.c_str(); } @@ -153,7 +153,7 @@ namespace fc const log_messages& exception::get_log()const { return my->_elog; } void exception::append_log( log_message m ) { - my->_elog.emplace_back( fc::move(m) ); + my->_elog.emplace_back( std::move(m) ); } /** @@ -220,7 +220,7 @@ namespace fc return std::make_shared(*this); } - fc::string except_str() + std::string except_str() { return boost::current_exception_diagnostic_information(); } diff --git a/src/filesystem.cpp b/src/filesystem.cpp index 5b89102..d6abc20 100644 --- a/src/filesystem.cpp +++ b/src/filesystem.cpp @@ -2,7 +2,6 @@ #include #include #include -#include #include #include @@ -52,7 +51,7 @@ namespace fc { path::path( const char* p ) :_p(p){} - path::path( const fc::string& p ) + path::path( const std::string& p ) :_p(p.c_str()){} path::path(const std::wstring& p) @@ -69,7 +68,7 @@ namespace fc { return *this; } path& path::operator =( path&& p ) { - *_p = fc::move( *p._p ); + *_p = std::move( *p._p ); return *this; } @@ -93,11 +92,11 @@ namespace fc { path::operator const boost::filesystem::path& ()const { return *_p; } - fc::string path::generic_string()const { + std::string path::generic_string()const { return _p->generic_string(); } - fc::string path::preferred_string() const + std::string path::preferred_string() const { return boost::filesystem::path(*_p).make_preferred().string(); } @@ -140,13 +139,13 @@ namespace fc { * @todo use iterators instead of indexes for * faster performance */ - fc::string path::windows_string()const { + std::string path::windows_string()const { std::string result = _p->generic_string(); std::replace(result.begin(), result.end(), '/', '\\'); return result; } - fc::string path::string()const { + std::string path::string()const { return _p->string(); } fc::path path::filename()const { @@ -502,101 +501,4 @@ namespace fc { return appCurrentPath; } - -#ifdef FC_HAS_SIMPLE_FILE_LOCK - class simple_lock_file::impl - { - public: -#ifdef _WIN32 - HANDLE file_handle; -#else - int file_handle; -#endif - bool is_locked; - path lock_file_path; - - impl(const path& lock_file_path); - ~impl(); - - bool try_lock(); - void unlock(); - }; - - simple_lock_file::impl::impl(const path& lock_file_path) : -#ifdef _WIN32 - file_handle(INVALID_HANDLE_VALUE), -#else - file_handle(-1), -#endif - is_locked(false), - lock_file_path(lock_file_path) - {} - - simple_lock_file::impl::~impl() - { - unlock(); - } - - bool simple_lock_file::impl::try_lock() - { -#ifdef _WIN32 - HANDLE fh = CreateFileA(lock_file_path.to_native_ansi_path().c_str(), - GENERIC_READ | GENERIC_WRITE, - 0, 0, - OPEN_ALWAYS, 0, NULL); - if (fh == INVALID_HANDLE_VALUE) - return false; - is_locked = true; - file_handle = fh; - return true; -#else - int fd = open(lock_file_path.string().c_str(), O_RDWR|O_CREAT, 0644); - if (fd < 0) - return false; - if (flock(fd, LOCK_EX|LOCK_NB) == -1) - { - close(fd); - return false; - } - is_locked = true; - file_handle = fd; - return true; -#endif - } - - void simple_lock_file::impl::unlock() - { -#ifdef WIN32 - CloseHandle(file_handle); - file_handle = INVALID_HANDLE_VALUE; - is_locked = false; -#else - flock(file_handle, LOCK_UN); - close(file_handle); - file_handle = -1; - is_locked = false; -#endif - } - - - simple_lock_file::simple_lock_file(const path& lock_file_path) : - my(new impl(lock_file_path)) - { - } - - simple_lock_file::~simple_lock_file() - { - } - - bool simple_lock_file::try_lock() - { - return my->try_lock(); - } - - void simple_lock_file::unlock() - { - my->unlock(); - } -#endif // FC_HAS_SIMPLE_FILE_LOCK - } diff --git a/src/interprocess/file_mutex.cpp b/src/interprocess/file_mutex.cpp deleted file mode 100644 index 72b142d..0000000 --- a/src/interprocess/file_mutex.cpp +++ /dev/null @@ -1,100 +0,0 @@ -#include -//#include -#include -#include -#include -#include -#include - -#include -#include - -namespace fc { - namespace bip = boost::interprocess; - - void yield(); - - namespace detail { - class file_mutex_impl { - public: - file_mutex_impl( const char* f ) - :_file_mutex( f ),_reader_count(0){} - - fc::mutex _write_lock; - bip::file_lock _file_mutex; - boost::atomic _reader_count; - }; - } - - file_mutex::file_mutex( const fc::path& file ) - { - my.reset( new detail::file_mutex_impl( file.generic_string().c_str() ) ); - } - - file_mutex::~file_mutex() { - } - - int file_mutex::readers()const { - return my->_reader_count.load(); - } - - bool file_mutex::try_lock() { - return false; - if( my->_write_lock.try_lock() ) { - if( my->_file_mutex.try_lock() ) - return true; - } - if( my->_file_mutex.try_lock() ) { - if( my->_write_lock.try_lock() ) { - return true; - } else { - my->_file_mutex.unlock(); - } - } - return false; - } - - bool file_mutex::try_lock_for( const microseconds& rel_time ) { - return false; - } - - bool file_mutex::try_lock_until( const time_point& abs_time ) { - return false; - } - - void file_mutex::lock() { - my->_write_lock.lock(); - while( my->_reader_count.load() > 0 ) { - fc::usleep( fc::microseconds(10) ); - } - my->_file_mutex.lock(); - } - - void file_mutex::unlock() { - my->_file_mutex.unlock(); - my->_write_lock.unlock(); - } - - void file_mutex::lock_shared() { - bip::scoped_lock< fc::mutex > lock( my->_write_lock ); - if( 0 == my->_reader_count.fetch_add( 1, boost::memory_order_relaxed ) ) - my->_file_mutex.lock_sharable(); - } - - void file_mutex::unlock_shared() { - if( 1 == my->_reader_count.fetch_add( -1, boost::memory_order_relaxed ) ) - my->_file_mutex.unlock_sharable(); - } - - bool file_mutex::try_lock_shared() { - return false; - if( my->_write_lock.try_lock() ) { - if( my->_reader_count.load() == 0 && my->_file_mutex.try_lock_sharable() ) { - my->_reader_count++; - } - my->_write_lock.unlock(); - } - return false; - } - -} // namespace fc diff --git a/src/interprocess/mmap_struct.cpp b/src/interprocess/mmap_struct.cpp deleted file mode 100644 index 8e9206c..0000000 --- a/src/interprocess/mmap_struct.cpp +++ /dev/null @@ -1,44 +0,0 @@ -#include - -#include - -#include - -#include -#include - -namespace fc -{ - namespace detail - { - size_t mmap_struct_base::size()const { return _mapped_region->get_size(); } - void mmap_struct_base::flush() - { - _mapped_region->flush(); - } - - void mmap_struct_base::open( const fc::path& file, size_t s, bool create ) - { - if( !fc::exists( file ) || fc::file_size(file) != s ) - { - fc::ofstream out( file ); - char buffer[1024]; - memset( buffer, 0, sizeof(buffer) ); - - size_t bytes_left = s; - while( bytes_left > 0 ) - { - size_t to_write = std::min(bytes_left, sizeof(buffer) ); - out.write( buffer, to_write ); - bytes_left -= to_write; - } - } - - std::string filePath = file.to_native_ansi_path(); - - _file_mapping.reset( new fc::file_mapping( filePath.c_str(), fc::read_write ) ); - _mapped_region.reset( new fc::mapped_region( *_file_mapping, fc::read_write, 0, s ) ); - } - } // namespace fc - -} // namespace fc diff --git a/src/io/buffered_iostream.cpp b/src/io/buffered_iostream.cpp index 0760621..5064772 100644 --- a/src/io/buffered_iostream.cpp +++ b/src/io/buffered_iostream.cpp @@ -13,7 +13,7 @@ namespace fc { public: buffered_istream_impl( istream_ptr is ) : - _istr(fc::move(is)) + _istr(std::move(is)) #ifndef NDEBUG ,_shared_read_buffer_in_use(false) #endif @@ -30,17 +30,17 @@ namespace fc } buffered_istream::buffered_istream( istream_ptr is ) - :my( new detail::buffered_istream_impl( fc::move(is) ) ) + :my( new detail::buffered_istream_impl( std::move(is) ) ) { FC_ASSERT( my->_istr != nullptr, " this shouldn't be null" ); } buffered_istream::buffered_istream( buffered_istream&& o ) - :my( fc::move(o.my) ){} + :my( std::move(o.my) ){} buffered_istream& buffered_istream::operator=( buffered_istream&& i ) { - my = fc::move(i.my); + my = std::move(i.my); return *this; } @@ -135,7 +135,7 @@ namespace fc { public: buffered_ostream_impl( ostream_ptr os ) : - _ostr(fc::move(os)) + _ostr(std::move(os)) #ifndef NDEBUG ,_shared_write_buffer_in_use(false) #endif @@ -151,16 +151,16 @@ namespace fc } buffered_ostream::buffered_ostream( ostream_ptr os, size_t bufsize ) - :my( new detail::buffered_ostream_impl( fc::move(os) ) ) + :my( new detail::buffered_ostream_impl( std::move(os) ) ) { } buffered_ostream::buffered_ostream( buffered_ostream&& o ) - :my( fc::move(o.my) ){} + :my( std::move(o.my) ){} buffered_ostream& buffered_ostream::operator=( buffered_ostream&& i ) { - my = fc::move(i.my); + my = std::move(i.my); return *this; } diff --git a/src/io/console.cpp b/src/io/console.cpp deleted file mode 100644 index c0cda18..0000000 --- a/src/io/console.cpp +++ /dev/null @@ -1,46 +0,0 @@ -#include -#include - -namespace fc { - -#ifdef WIN32 -#include - -void set_console_echo( bool enable_echo ) -{ - auto stdin_handle = GetStdHandle( STD_INPUT_HANDLE ); - DWORD mode = 0; - GetConsoleMode( stdin_handle, &mode ); - if( enable_echo ) - { - SetConsoleMode( stdin_handle, mode | ENABLE_ECHO_INPUT ); - } - else - { - SetConsoleMode( stdin_handle, mode & (~ENABLE_ECHO_INPUT) ); - } -} - -#else // NOT WIN32 -#include -#include - -void set_console_echo( bool enable_echo ) -{ - termios oldt; - tcgetattr(STDIN_FILENO, &oldt); - termios newt = oldt; - if( enable_echo ) - { - newt.c_lflag |= ECHO; - } - else - { - newt.c_lflag &= ~ECHO; - } - tcsetattr(STDIN_FILENO, TCSANOW, &newt); -} - -#endif // WIN32 - -} // namespace fc diff --git a/src/io/datastream.cpp b/src/io/datastream.cpp index cfe1104..69fda0d 100644 --- a/src/io/datastream.cpp +++ b/src/io/datastream.cpp @@ -3,5 +3,5 @@ NO_RETURN void fc::detail::throw_datastream_range_error(char const* method, size_t len, int64_t over) { - FC_THROW_EXCEPTION( out_of_range_exception, "${method} datastream of length ${len} over by ${over}", ("method",fc::string(method))("len",len)("over",over) ); + FC_THROW_EXCEPTION( out_of_range_exception, "${method} datastream of length ${len} over by ${over}", ("method",std::string(method))("len",len)("over",over) ); } diff --git a/src/io/iostream.cpp b/src/io/iostream.cpp index 3a16027..4c4a0cc 100644 --- a/src/io/iostream.cpp +++ b/src/io/iostream.cpp @@ -3,7 +3,6 @@ #include #include #include -//#include #include #include #include @@ -76,7 +75,7 @@ namespace fc { fc::thread& cin_thread() { static fc::thread i("cin"); return i; } - fc::istream& getline( fc::istream& i, fc::string& s, char delim ) { + fc::istream& getline( fc::istream& i, std::string& s, char delim ) { fc::stringstream ss; char c; i.read( &c, 1 ); @@ -104,7 +103,7 @@ namespace fc { size_t cin_t::readsome( char* buf, size_t len ) { cin_buffer& b = get_cin_buffer(); int64_t avail = b.write_pos - b.read_pos; - avail = (fc::min)(int64_t(len),avail); + avail = (std::min)(int64_t(len),avail); int64_t u = 0; if( !((avail>0) && (len>0)) ) { @@ -194,13 +193,6 @@ namespace fc { o.write( v.c_str(), v.size() ); return o; } -#ifdef USE_FC_STRING - ostream& operator<<( ostream& o, const fc::string& v ) - { - o.write( v.c_str(), v.size() ); - return o; - } -#endif ostream& operator<<( ostream& o, const double& v ) { @@ -266,14 +258,6 @@ namespace fc { return o; } -#ifdef USE_FC_STRING - istream& operator>>( istream& o, fc::string& v ) - { - assert(false && "not implemented"); - return o; - } -#endif - istream& operator>>( istream& o, char& v ) { o.read(&v,1); diff --git a/src/io/json.cpp b/src/io/json.cpp index 712973c..c5a1fc9 100644 --- a/src/io/json.cpp +++ b/src/io/json.cpp @@ -17,9 +17,9 @@ namespace fc // forward declarations of provided functions template variant variant_from_stream( T& in, uint32_t max_depth ); template char parseEscape( T& in ); - template fc::string stringFromStream( T& in ); + template std::string stringFromStream( T& in ); template bool skip_white_space( T& in ); - template fc::string stringFromToken( T& in ); + template std::string stringFromToken( T& in ); template variant_object objectFromStreamBase( T& in, std::function& get_key, std::function& get_value ); template variant_object objectFromStream( T& in, uint32_t max_depth ); template variants arrayFromStreamBase( T& in, std::function& get_value ); @@ -30,7 +30,7 @@ namespace fc template void to_stream( T& os, const variants& a, json::output_formatting format, uint32_t max_depth ); template void to_stream( T& os, const variant_object& o, json::output_formatting format, uint32_t max_depth ); template void to_stream( T& os, const variant& v, json::output_formatting format, uint32_t max_depth ); - fc::string pretty_print( const fc::string& v, uint8_t indent ); + std::string pretty_print( const std::string& v, uint8_t indent ); } #if __cplusplus > 201402L @@ -94,7 +94,7 @@ namespace fc } template - fc::string stringFromStream( T& in ) + std::string stringFromStream( T& in ) { fc::stringstream token; try @@ -131,7 +131,7 @@ namespace fc ("token", token.str() ) ); } template - fc::string stringFromToken( T& in ) + std::string stringFromToken( T& in ) { fc::stringstream token; try @@ -324,7 +324,7 @@ namespace fc catch (const std::ios_base::failure&) { // read error ends the loop } - fc::string str = ss.str(); + std::string str = ss.str(); if (str == "-." || str == "." || str == "-") // check the obviously wrong things we could have encountered FC_THROW_EXCEPTION(parse_error_exception, "Can't parse token \"${token}\" as a JSON numeric constant", ("token", str)); if( dot ) @@ -380,7 +380,7 @@ namespace fc // we can get here either by processing a delimiter as in "null," // an EOF like "null", or an invalid token like "nullZ" - fc::string str = ss.str(); + std::string str = ss.str(); if( str == "null" ) return variant(); if( str == "true" ) @@ -547,7 +547,7 @@ namespace fc } os << '"'; } - ostream& json::to_stream( ostream& out, const fc::string& str ) + ostream& json::to_stream( ostream& out, const std::string& str ) { escape_string( str, out ); return out; @@ -635,7 +635,7 @@ namespace fc } } - fc::string json::to_string( const variant& v, output_formatting format, uint32_t max_depth ) + std::string json::to_string( const variant& v, output_formatting format, uint32_t max_depth ) { fc::stringstream ss; fc::to_stream( ss, v, format, max_depth ); @@ -643,7 +643,7 @@ namespace fc } - fc::string pretty_print( const fc::string& v, uint8_t indent ) { + std::string pretty_print( const std::string& v, uint8_t indent ) { int level = 0; fc::stringstream ss; bool first = false; @@ -733,7 +733,7 @@ namespace fc - fc::string json::to_pretty_string( const variant& v, output_formatting format, uint32_t max_depth ) + std::string json::to_pretty_string( const variant& v, output_formatting format, uint32_t max_depth ) { return pretty_print(to_string(v, format, max_depth), 2); } diff --git a/src/io/sstream.cpp b/src/io/sstream.cpp index 9c4739e..70977c0 100644 --- a/src/io/sstream.cpp +++ b/src/io/sstream.cpp @@ -7,11 +7,11 @@ namespace fc { class stringstream::impl { public: - impl( fc::string&s ) + impl( std::string&s ) :ss( s ) { ss.exceptions( std::stringstream::badbit ); } - impl( const fc::string&s ) + impl( const std::string&s ) :ss( s ) { ss.exceptions( std::stringstream::badbit ); } @@ -20,21 +20,21 @@ namespace fc { std::stringstream ss; }; - stringstream::stringstream( fc::string& s ) + stringstream::stringstream( std::string& s ) :my(s) { } - stringstream::stringstream( const fc::string& s ) + stringstream::stringstream( const std::string& s ) :my(s) { } stringstream::stringstream(){} stringstream::~stringstream(){} - fc::string stringstream::str(){ - return my->ss.str();//.c_str();//*reinterpret_cast(&st); + std::string stringstream::str(){ + return my->ss.str();//.c_str();//*reinterpret_cast(&st); } - void stringstream::str(const fc::string& s) { + void stringstream::str(const std::string& s) { my->ss.str(s); } @@ -93,9 +93,9 @@ namespace fc { istream& stringstream::read( double& v ) { my->ss >> v; return *this; } istream& stringstream::read( bool& v ) { my->ss >> v; return *this; } istream& stringstream::read( char& v ) { my->ss >> v; return *this; } - istream& stringstream::read( fc::string& v ) { my->ss >> *reinterpret_cast(&v); return *this; } + istream& stringstream::read( std::string& v ) { my->ss >> *reinterpret_cast(&v); return *this; } - ostream& stringstream::write( const fc::string& s) { + ostream& stringstream::write( const std::string& s) { my->ss.write( s.c_str(), s.size() ); return *this; } diff --git a/src/log/appender.cpp b/src/log/appender.cpp index c4d9c9e..3d88a2c 100644 --- a/src/log/appender.cpp +++ b/src/log/appender.cpp @@ -22,17 +22,17 @@ namespace fc { static std::unordered_map lm; return lm; } - appender::ptr appender::get( const fc::string& s ) { + appender::ptr appender::get( const std::string& s ) { static fc::spin_lock appender_spinlock; scoped_lock lock(appender_spinlock); return get_appender_map()[s]; } - bool appender::register_appender( const fc::string& type, const appender_factory::ptr& f ) + bool appender::register_appender( const std::string& type, const appender_factory::ptr& f ) { get_appender_factory_map()[type] = f; return true; } - appender::ptr appender::create( const fc::string& name, const fc::string& type, const variant& args ) + appender::ptr appender::create( const std::string& name, const std::string& type, const variant& args ) { auto fact_itr = get_appender_factory_map().find(type); if( fact_itr == get_appender_factory_map().end() ) { diff --git a/src/log/console_appender.cpp b/src/log/console_appender.cpp index af35564..41a9972 100644 --- a/src/log/console_appender.cpp +++ b/src/log/console_appender.cpp @@ -1,7 +1,6 @@ #include #include #include -#include #include #include #ifndef WIN32 @@ -114,7 +113,7 @@ namespace fc { line << std::setw( 20 ) << std::left << m.get_context().get_method().substr(p,20).c_str() <<" "; } line << "] "; - fc::string message = fc::format_string( m.get_format(), m.get_data(), my->cfg.max_object_depth ); + std::string message = fc::format_string( m.get_format(), m.get_data(), my->cfg.max_object_depth ); line << message; fc::unique_lock lock(log_mutex()); diff --git a/src/log/file_appender.cpp b/src/log/file_appender.cpp index 270c3dd..6cc1d7e 100644 --- a/src/log/file_appender.cpp +++ b/src/log/file_appender.cpp @@ -172,7 +172,7 @@ namespace fc { } line << "] "; - fc::string message = fc::format_string( m.get_format(), m.get_data(), my->cfg.max_object_depth ); + std::string message = fc::format_string( m.get_format(), m.get_data(), my->cfg.max_object_depth ); line << message.c_str(); { diff --git a/src/log/log_message.cpp b/src/log/log_message.cpp index cf8d27a..b2873b7 100644 --- a/src/log/log_message.cpp +++ b/src/log/log_message.cpp @@ -75,13 +75,13 @@ namespace fc my->context = obj["context"].as(max_depth); } - fc::string log_context::to_string()const + std::string log_context::to_string()const { return my->thread_name + " " + my->file + ":" + fc::to_string(my->line) + " " + my->method; } - void log_context::append_context( const fc::string& s ) + void log_context::append_context( const std::string& s ) { if (!my->context.empty()) my->context += " -> "; diff --git a/src/log/logger.cpp b/src/log/logger.cpp index 8c4f149..93241f3 100644 --- a/src/log/logger.cpp +++ b/src/log/logger.cpp @@ -15,7 +15,7 @@ namespace fc { public: impl() :_parent(nullptr),_enabled(true),_additivity(false),_level(log_level::warn){} - fc::string _name; + std::string _name; logger _parent; bool _enabled; bool _additivity; @@ -42,7 +42,7 @@ namespace fc { :my(l.my){} logger::logger( logger&& l ) - :my(fc::move(l.my)){} + :my(std::move(l.my)){} logger::~logger(){} @@ -51,7 +51,7 @@ namespace fc { return *this; } logger& logger::operator=( logger&& l ){ - fc_swap(my,l.my); + std::swap(my,l.my); return *this; } bool operator==( const logger& l, std::nullptr_t ) { return !l.my; } @@ -71,8 +71,8 @@ namespace fc { my->_parent.log(m); } } - void logger::set_name( const fc::string& n ) { my->_name = n; } - const fc::string& logger::name()const { return my->_name; } + void logger::set_name( const std::string& n ) { my->_name = n; } + const std::string& logger::name()const { return my->_name; } extern bool do_default_config; @@ -84,7 +84,7 @@ namespace fc { return *lm; } - logger logger::get( const fc::string& s ) { + logger logger::get( const std::string& s ) { static fc::spin_lock logger_spinlock; scoped_lock lock(logger_spinlock); return get_logger_map()[s]; diff --git a/src/network/http/http_connection.cpp b/src/network/http/http_connection.cpp index 59fb39b..a870ff5 100644 --- a/src/network/http/http_connection.cpp +++ b/src/network/http/http_connection.cpp @@ -42,22 +42,22 @@ class fc::http::connection::impl std::vector line(1024*8); int s = read_until( line.data(), line.data()+line.size(), ' ' ); // HTTP/1.1 s = read_until( line.data(), line.data()+line.size(), ' ' ); // CODE - rep.status = static_cast(to_int64(fc::string(line.data()))); + rep.status = static_cast(to_int64(std::string(line.data()))); s = read_until( line.data(), line.data()+line.size(), '\n' ); // DESCRIPTION while( (s = read_until( line.data(), line.data()+line.size(), '\n' )) > 1 ) { fc::http::header h; char* end = line.data(); while( *end != ':' )++end; - h.key = fc::string(line.data(),end); + h.key = std::string(line.data(),end); ++end; // skip ':' ++end; // skip space char* skey = end; while( *end != '\r' ) ++end; - h.val = fc::string(skey,end); + h.val = std::string(skey,end); rep.headers.push_back(h); if( boost::iequals(h.key, "Content-Length") ) { - rep.body.resize( static_cast(to_uint64( fc::string(h.val) ) )); + rep.body.resize( static_cast(to_uint64( std::string(h.val) ) )); } } if( rep.body.size() ) { @@ -88,9 +88,9 @@ void connection::connect_to( const fc::ip::endpoint& ep ) { my->sock.connect_to( my->ep = ep ); } -http::reply connection::request( const fc::string& method, - const fc::string& url, - const fc::string& body, const headers& he ) { +http::reply connection::request( const std::string& method, + const std::string& url, + const std::string& body, const headers& he ) { fc::url parsed_url(url); if( !my->sock.is_open() ) { @@ -108,7 +108,7 @@ http::reply connection::request( const fc::string& method, } if( body.size() ) req << "Content-Length: "<< body.size() << "\r\n"; req << "\r\n"; - fc::string head = req.str(); + std::string head = req.str(); my->sock.write( head.c_str(), head.size() ); // fc::cerr.write( head.c_str() ); @@ -146,17 +146,17 @@ http::request connection::read_request()const { fc::http::header h; char* end = line.data(); while( *end != ':' )++end; - h.key = fc::string(line.data(),end); + h.key = std::string(line.data(),end); ++end; // skip ':' ++end; // skip space char* skey = end; while( *end != '\r' ) ++end; - h.val = fc::string(skey,end); + h.val = std::string(skey,end); req.headers.push_back(h); if( boost::iequals(h.key, "Content-Length")) { - auto s = static_cast(to_uint64( fc::string(h.val) ) ); + auto s = static_cast(to_uint64( std::string(h.val) ) ); FC_ASSERT( s < 1024*1024 ); - req.body.resize( static_cast(to_uint64( fc::string(h.val) ) )); + req.body.resize( static_cast(to_uint64( std::string(h.val) ) )); } if( boost::iequals(h.key, "Host") ) { req.domain = h.val; @@ -171,13 +171,13 @@ http::request connection::read_request()const { return req; } -fc::string request::get_header( const fc::string& key )const { +std::string request::get_header( const std::string& key )const { for( auto itr = headers.begin(); itr != headers.end(); ++itr ) { if( boost::iequals(itr->key, key) ) { return itr->val; } } - return fc::string(); + return std::string(); } -std::vector
parse_urlencoded_params( const fc::string& f ) { +std::vector
parse_urlencoded_params( const std::string& f ) { int num_args = 0; for( size_t i = 0; i < f.size(); ++i ) { if( f[i] == '=' ) ++num_args; diff --git a/src/network/http/http_server.cpp b/src/network/http/http_server.cpp index 648fc54..8a63734 100644 --- a/src/network/http/http_server.cpp +++ b/src/network/http/http_server.cpp @@ -135,9 +135,9 @@ namespace fc { namespace http { server::server():my( new impl() ){} server::server( uint16_t port ) :my( new impl(fc::ip::endpoint( fc::ip::address(),port)) ){} - server::server( server&& s ):my(fc::move(s.my)){} + server::server( server&& s ):my(std::move(s.my)){} - server& server::operator=(server&& s) { fc_swap(my,s.my); return *this; } + server& server::operator=(server&& s) { std::swap(my,s.my); return *this; } server::~server(){} @@ -154,13 +154,13 @@ namespace fc { namespace http { server::response::response(){} server::response::response( const server::response& s ):my(s.my){} - server::response::response( server::response&& s ):my(fc::move(s.my)){} + server::response::response( server::response&& s ):my(std::move(s.my)){} server::response::response( const fc::shared_ptr& m ):my(m){} server::response& server::response::operator=(const server::response& s) { my = s.my; return *this; } - server::response& server::response::operator=(server::response&& s) { fc_swap(my,s.my); return *this; } + server::response& server::response::operator=(server::response&& s) { std::swap(my,s.my); return *this; } - void server::response::add_header( const fc::string& key, const fc::string& val )const { + void server::response::add_header( const std::string& key, const std::string& val )const { my->rep.headers.push_back( fc::http::header( key, val ) ); } void server::response::set_status( const http::reply::status_code& s )const { diff --git a/src/network/ip.cpp b/src/network/ip.cpp index 570a621..daff7f9 100644 --- a/src/network/ip.cpp +++ b/src/network/ip.cpp @@ -10,7 +10,7 @@ namespace fc { namespace ip { address::address( uint32_t ip ) :_ip(ip){} - address::address( const fc::string& s ) + address::address( const std::string& s ) { try { @@ -26,7 +26,7 @@ namespace fc { namespace ip { return uint32_t(a) != uint32_t(b); } - address& address::operator=( const fc::string& s ) + address& address::operator=( const std::string& s ) { try { @@ -36,7 +36,7 @@ namespace fc { namespace ip { return *this; } - address::operator fc::string()const + address::operator std::string()const { try { @@ -88,7 +88,7 @@ namespace fc { namespace ip { { try { - return string(_ip) + ':' + fc::string(boost::lexical_cast(_port).c_str()); + return string(_ip) + ':' + std::string(boost::lexical_cast(_port).c_str()); } FC_RETHROW_EXCEPTIONS(warn, "error converting IP endpoint to string") } @@ -139,7 +139,7 @@ namespace fc { namespace ip { void to_variant( const ip::endpoint& var, variant& vo, uint32_t max_depth ) { - vo = fc::string(var); + vo = std::string(var); } void from_variant( const variant& var, ip::endpoint& vo, uint32_t max_depth ) { @@ -148,7 +148,7 @@ namespace fc { namespace ip { void to_variant( const ip::address& var, variant& vo, uint32_t max_depth ) { - vo = fc::string(var); + vo = std::string(var); } void from_variant( const variant& var, ip::address& vo, uint32_t max_depth ) { diff --git a/src/network/resolve.cpp b/src/network/resolve.cpp index 3e9ec28..508d292 100644 --- a/src/network/resolve.cpp +++ b/src/network/resolve.cpp @@ -4,7 +4,7 @@ namespace fc { - std::vector resolve( const fc::string& host, uint16_t port ) + std::vector resolve( const std::string& host, uint16_t port ) { auto ep = fc::asio::tcp::resolve( host, std::to_string(uint64_t(port)) ); std::vector eps; diff --git a/src/network/url.cpp b/src/network/url.cpp index 73d0536..403aaae 100644 --- a/src/network/url.cpp +++ b/src/network/url.cpp @@ -1,5 +1,4 @@ #include -#include #include #include #include @@ -12,7 +11,7 @@ namespace fc class url_impl { public: - void parse( const fc::string& s ) + void parse( const std::string& s ) { std::stringstream ss(s); std::string skip,_lpath,_largs,luser,lpass; @@ -20,23 +19,23 @@ namespace fc std::getline( ss, skip, '/' ); std::getline( ss, skip, '/' ); - if( s.find('@') != size_t(fc::string::npos) ) { - fc::string user_pass; + if( s.find('@') != size_t(std::string::npos) ) { + std::string user_pass; std::getline( ss, user_pass, '@' ); std::stringstream upss(user_pass); - if( user_pass.find( ':' ) != size_t(fc::string::npos) ) { + if( user_pass.find( ':' ) != size_t(std::string::npos) ) { std::getline( upss, luser, ':' ); std::getline( upss, lpass, ':' ); - _user = fc::move(luser); - _pass = fc::move(lpass); + _user = std::move(luser); + _pass = std::move(lpass); } else { - _user = fc::move(user_pass); + _user = std::move(user_pass); } } - fc::string host_port; + std::string host_port; std::getline( ss, host_port, '/' ); auto pos = host_port.find( ':' ); - if( pos != fc::string::npos ) { + if( pos != std::string::npos ) { try { _port = static_cast(to_uint64( host_port.substr( pos+1 ) )); } catch ( ... ) { @@ -44,7 +43,7 @@ namespace fc } _host = host_port.substr(0,pos); } else { - _host = fc::move(host_port); + _host = std::move(host_port); } std::getline( ss, _lpath, '?' ); #ifdef WIN32 @@ -62,7 +61,7 @@ namespace fc std::getline( ss, _largs ); if( _args.valid() && _args->size() ) { - // TODO: args = fc::move(_args); + // TODO: args = std::move(_args); } } @@ -78,7 +77,7 @@ namespace fc void to_variant( const url& u, fc::variant& v, uint32_t max_depth ) { - v = fc::string(u); + v = std::string(u); } void from_variant( const fc::variant& v, url& u, uint32_t max_depth ) { @@ -102,7 +101,7 @@ namespace fc return ss.str(); } - url::url( const fc::string& u ) + url::url( const std::string& u ) :my( std::make_shared() ) { my->parse(u); @@ -122,7 +121,7 @@ namespace fc :my(u.my){} url::url( url&& u ) - :my( fc::move(u.my) ) + :my( std::move(u.my) ) { u.my = get_null_url(); } @@ -133,7 +132,7 @@ namespace fc } url::url( mutable_url&& mu ) - :my( fc::move( mu.my ) ) + :my( std::move( mu.my ) ) { } url::~url(){} @@ -148,7 +147,7 @@ namespace fc { if( this != &u ) { - my = fc::move(u.my); + my = std::move(u.my); u.my= get_null_url(); } return *this; @@ -160,7 +159,7 @@ namespace fc } url& url::operator=(mutable_url&& u ) { - my = fc::move(u.my); + my = std::move(u.my); return *this; } diff --git a/src/rpc/bstate.cpp b/src/rpc/bstate.cpp index 832f8ce..b6b39fd 100644 --- a/src/rpc/bstate.cpp +++ b/src/rpc/bstate.cpp @@ -8,12 +8,12 @@ bstate::~bstate() close(); } -void bstate::add_method( const fc::string& name, method m ) +void bstate::add_method( const std::string& name, method m ) { - _methods.emplace(std::pair(name,fc::move(m))); + _methods.emplace(std::pair(name,std::move(m))); } -void bstate::remove_method( const fc::string& name ) +void bstate::remove_method( const std::string& name ) { _methods.erase(name); } diff --git a/src/rpc/cli.cpp b/src/rpc/cli.cpp index d106253..658a968 100644 --- a/src/rpc/cli.cpp +++ b/src/rpc/cli.cpp @@ -221,7 +221,7 @@ static int cli_check_secret(const char *source) * @param prompt the prompt to display * @param line what the user typed */ -void cli::getline( const fc::string& prompt, fc::string& line) +void cli::getline( const std::string& prompt, std::string& line) { // getting file descriptor for C++ streams is near impossible // so we just assume it's the same as the C stream... diff --git a/src/rpc/json_connection.cpp b/src/rpc/json_connection.cpp index fd19f27..8eea0df 100644 --- a/src/rpc/json_connection.cpp +++ b/src/rpc/json_connection.cpp @@ -15,7 +15,7 @@ namespace fc { namespace rpc { { public: json_connection_impl( fc::buffered_istream_ptr&& in, fc::buffered_ostream_ptr&& out, uint32_t max_depth ) - :_in(fc::move(in)),_out(fc::move(out)),_eof(false),_next_id(0),_logger("json_connection"),_max_depth(max_depth){} + :_in(std::move(in)),_out(std::move(out)),_eof(false),_next_id(0),_logger("json_connection"),_max_depth(max_depth){} fc::buffered_istream_ptr _in; fc::buffered_ostream_ptr _out; @@ -57,7 +57,7 @@ namespace fc { namespace rpc { *_out << "{\"id\":"; json::to_stream( *_out, id, json::stringify_large_ints_and_doubles, _max_depth ); *_out << ",\"error\":{\"message\":"; - json::to_stream( *_out, fc::string(e.what()) ); + json::to_stream( *_out, std::string(e.what()) ); *_out <<",\"code\":0,\"data\":"; json::to_stream( *_out, variant(e, _max_depth), json::stringify_large_ints_and_doubles, _max_depth ); *_out << "}}\n"; @@ -202,7 +202,7 @@ namespace fc { namespace rpc { fc::exception_ptr eptr; try { - fc::string line; + std::string line; while( !_done.canceled() ) { variant v = json::from_stream( *_in, json::legacy_parser, _max_depth ); @@ -241,7 +241,7 @@ namespace fc { namespace rpc { }//namespace detail json_connection::json_connection( fc::buffered_istream_ptr in, fc::buffered_ostream_ptr out, uint32_t max_depth ) - :_max_conversion_depth(max_depth),my( new detail::json_connection_impl(fc::move(in),fc::move(out),max_depth) ) + :_max_conversion_depth(max_depth),my( new detail::json_connection_impl(std::move(in),std::move(out),max_depth) ) {} json_connection::~json_connection() @@ -285,22 +285,22 @@ namespace fc { namespace rpc { my->_on_close = callback; } - void json_connection::add_method( const fc::string& name, method m ) + void json_connection::add_method( const std::string& name, method m ) { ilog( "add method ${name}", ("name",name) ); - my->_methods.emplace(std::pair(name,fc::move(m))); + my->_methods.emplace(std::pair(name,std::move(m))); } - void json_connection::add_named_param_method( const fc::string& name, named_param_method m ) + void json_connection::add_named_param_method( const std::string& name, named_param_method m ) { ilog( "add named param method ${name}", ("name",name) ); - my->_named_param_methods.emplace(std::pair(name,fc::move(m))); + my->_named_param_methods.emplace(std::pair(name,std::move(m))); } - void json_connection::remove_method( const fc::string& name ) + void json_connection::remove_method( const std::string& name ) { my->_methods.erase(name); my->_named_param_methods.erase(name); } - void json_connection::notice( const fc::string& method, const variants& args ) + void json_connection::notice( const std::string& method, const variants& args ) { fc::scoped_lock lock(my->_write_mutex); *my->_out << "{\"method\":"; @@ -316,7 +316,7 @@ namespace fc { namespace rpc { *my->_out << ",\"params\":[]}\n"; } } - void json_connection::notice( const fc::string& method, const variant_object& named_args ) + void json_connection::notice( const std::string& method, const variant_object& named_args ) { { fc::scoped_lock lock(my->_write_mutex); @@ -328,7 +328,7 @@ namespace fc { namespace rpc { my->_out->flush(); } } - void json_connection::notice( const fc::string& method ) + void json_connection::notice( const std::string& method ) { { fc::scoped_lock lock(my->_write_mutex); @@ -340,7 +340,7 @@ namespace fc { namespace rpc { } - future json_connection::async_call( const fc::string& method, const variants& args ) + future json_connection::async_call( const std::string& method, const variants& args ) { auto id = my->_next_id++; my->_awaiting[id] = fc::promise::ptr( new fc::promise("json_connection::async_call") ); @@ -366,7 +366,7 @@ namespace fc { namespace rpc { return my->_awaiting[id]; } - future json_connection::async_call( const fc::string& method, const variant& a1 ) + future json_connection::async_call( const std::string& method, const variant& a1 ) { auto id = my->_next_id++; my->_awaiting[id] = fc::promise::ptr( new fc::promise("json_connection::async_call") ); @@ -384,7 +384,7 @@ namespace fc { namespace rpc { } return my->_awaiting[id]; } - future json_connection::async_call( const fc::string& method, const variant& a1, const variant& a2 ) + future json_connection::async_call( const std::string& method, const variant& a1, const variant& a2 ) { auto id = my->_next_id++; my->_awaiting[id] = fc::promise::ptr( new fc::promise("json_connection::async_call") ); @@ -404,7 +404,7 @@ namespace fc { namespace rpc { } return my->_awaiting[id]; } - future json_connection::async_call( const fc::string& method, const variant& a1, const variant& a2, const variant& a3 ) + future json_connection::async_call( const std::string& method, const variant& a1, const variant& a2, const variant& a3 ) { auto id = my->_next_id++; my->_awaiting[id] = fc::promise::ptr( new fc::promise("json_connection::async_call") ); @@ -427,7 +427,7 @@ namespace fc { namespace rpc { return my->_awaiting[id]; } - future json_connection::async_call( const fc::string& method, const variant& a1, const variant& a2, const variant& a3, const variant& a4 ) + future json_connection::async_call( const std::string& method, const variant& a1, const variant& a2, const variant& a3, const variant& a4 ) { auto id = my->_next_id++; my->_awaiting[id] = fc::promise::ptr( new fc::promise("json_connection::async_call") ); @@ -452,7 +452,7 @@ namespace fc { namespace rpc { return my->_awaiting[id]; } - future json_connection::async_call( const fc::string& method, const variant& a1, const variant& a2, const variant& a3, const variant& a4, const variant& a5 ) + future json_connection::async_call( const std::string& method, const variant& a1, const variant& a2, const variant& a3, const variant& a4, const variant& a5 ) { auto id = my->_next_id++; my->_awaiting[id] = fc::promise::ptr( new fc::promise("json_connection::async_call") ); @@ -479,7 +479,7 @@ namespace fc { namespace rpc { return my->_awaiting[id]; } - future json_connection::async_call( const fc::string& method, const variant& a1, const variant& a2, const variant& a3, const variant& a4, const variant& a5, const variant& a6 ) + future json_connection::async_call( const std::string& method, const variant& a1, const variant& a2, const variant& a3, const variant& a4, const variant& a5, const variant& a6 ) { auto id = my->_next_id++; my->_awaiting[id] = fc::promise::ptr( new fc::promise("json_connection::async_call") ); @@ -507,7 +507,7 @@ namespace fc { namespace rpc { } return my->_awaiting[id]; } - future json_connection::async_call( const fc::string& method, const variant& a1, const variant& a2, const variant& a3, const variant& a4, const variant& a5, const variant& a6, const variant& a7 ) + future json_connection::async_call( const std::string& method, const variant& a1, const variant& a2, const variant& a3, const variant& a4, const variant& a5, const variant& a6, const variant& a7 ) { auto id = my->_next_id++; my->_awaiting[id] = fc::promise::ptr( new fc::promise("json_connection::async_call") ); @@ -537,7 +537,7 @@ namespace fc { namespace rpc { } return my->_awaiting[id]; } - future json_connection::async_call( const fc::string& method, + future json_connection::async_call( const std::string& method, const variant& a1, const variant& a2, const variant& a3, @@ -577,7 +577,7 @@ namespace fc { namespace rpc { } return my->_awaiting[id]; } - future json_connection::async_call( const fc::string& method, + future json_connection::async_call( const std::string& method, const variant& a1, const variant& a2, const variant& a3, @@ -620,7 +620,7 @@ namespace fc { namespace rpc { } return my->_awaiting[id]; } - future json_connection::async_call( const fc::string& method, + future json_connection::async_call( const std::string& method, const variant& a1, const variant& a2, const variant& a3, @@ -667,11 +667,11 @@ namespace fc { namespace rpc { return my->_awaiting[id]; } - future json_connection::async_call( const fc::string& method, mutable_variant_object named_args ) + future json_connection::async_call( const std::string& method, mutable_variant_object named_args ) { - return async_call( method, variant_object( fc::move(named_args) ) ); + return async_call( method, variant_object( std::move(named_args) ) ); } - future json_connection::async_call( const fc::string& method, const variant_object& named_args ) + future json_connection::async_call( const std::string& method, const variant_object& named_args ) { auto id = my->_next_id++; my->_awaiting[id] = fc::promise::ptr( new fc::promise("json_connection::async_call") ); @@ -688,7 +688,7 @@ namespace fc { namespace rpc { } return my->_awaiting[id]; } - future json_connection::async_call( const fc::string& method ) + future json_connection::async_call( const std::string& method ) { auto id = my->_next_id++; my->_awaiting[id] = fc::promise::ptr( new fc::promise("json_connection::async_call") ); diff --git a/src/rpc/state.cpp b/src/rpc/state.cpp index 7d4063d..20823e3 100644 --- a/src/rpc/state.cpp +++ b/src/rpc/state.cpp @@ -8,12 +8,12 @@ state::~state() close(); } -void state::add_method( const fc::string& name, method m ) +void state::add_method( const std::string& name, method m ) { - _methods.emplace(std::pair(name,fc::move(m))); + _methods.emplace(std::pair(name,std::move(m))); } -void state::remove_method( const fc::string& name ) +void state::remove_method( const std::string& name ) { _methods.erase(name); } diff --git a/src/string.cpp b/src/string.cpp index 2432360..ea63732 100644 --- a/src/string.cpp +++ b/src/string.cpp @@ -1,5 +1,3 @@ -#include -#include #include #include #include @@ -33,65 +31,7 @@ namespace fc { return ss.str(); } -#ifdef USE_FC_STRING - string::string(const char* s, int l) :my(s,l){ } - string::string(){} - string::string( const fc::string& c ):my(*c.my) { } - string::string( string&& m ):my(fc::move(*m.my)) {} - string::string( const char* c ):my(c){} - string::string( const_iterator b, const_iterator e ):my(b,e){} - string::string( const std::string& s ):my(s) {} - string::string( std::string&& s ):my(fc::move(s)) {} - string::~string() { } - string::operator std::string&() { return *my; } - string::operator const std::string&()const { return *my; } - char* string::data() { return &my->front(); } - - string::iterator string::begin() { return &(*this)[0]; } - string::iterator string::end() { return &(*this)[size()]; } - string::const_iterator string::begin()const { return my->c_str(); } - string::const_iterator string::end()const { return my->c_str() + my->size(); } - - char& string::operator[](size_t idx) { return (*my)[idx]; } - const char& string::operator[](size_t idx)const { return (*my)[idx]; } - - void string::reserve(size_t r) { my->reserve(r); } - size_t string::size()const { return my->size(); } - size_t string::find(char c, size_t p)const { return my->find(c,p); } - size_t string::find(const fc::string& str, size_t pos /* = 0 */) const { return my->find(str, pos); } - size_t string::find(const char* s, size_t pos /* = 0 */) const { return my->find(s,pos); } - size_t string::rfind(char c, size_t p)const { return my->rfind(c,p); } - size_t string::rfind(const char* c, size_t p)const { return my->rfind(c,p); } - size_t string::rfind(const fc::string& c, size_t p)const { return my->rfind(c,p); } - size_t string::find_first_of(const fc::string& str, size_t pos /* = 0 */) const { return my->find_first_of(str, pos); } - size_t string::find_first_of(const char* s, size_t pos /* = 0 */) const { return my->find_first_of(s, pos); } - - fc::string& string::replace(size_t pos, size_t len, const string& str) { my->replace(pos, len, str); return *this; } - fc::string& string::replace(size_t pos, size_t len, const char* s) { my->replace(pos, len, s); return *this; } - - void string::clear() { my->clear(); } - void string::resize( size_t s ) { my->resize(s); } - - fc::string string::substr( size_t start, size_t len )const { return my->substr(start,len); } - const char* string::c_str()const { return my->c_str(); } - - bool string::operator == ( const char* s )const { return *my == s; } - bool string::operator == ( const string& s )const { return *my == *s.my; } - bool string::operator != ( const string& s )const { return *my != *s.my; } - - string& string::operator =( const string& c ) { *my = *c.my; return *this; } - string& string::operator =( string&& c ) { *my = fc::move( *c.my ); return *this; } - - string& string::operator+=( const string& s ) { *my += *s.my; return *this; } - string& string::operator+=( char c ) { *my += c; return *this; } - - bool operator < ( const string& a, const string& b ) { return *a.my < *b.my; } - string operator + ( const string& s, const string& c ) { return string(s) += c; } - string operator + ( const string& s, char c ) { return string(s) += c; } -#endif // USE_FC_STRING - - - int64_t to_int64( const fc::string& i ) + int64_t to_int64( const std::string& i ) { try { @@ -104,7 +44,7 @@ namespace fc { FC_RETHROW_EXCEPTIONS( warn, "${i} => int64_t", ("i",i) ) } - uint64_t to_uint64( const fc::string& i ) + uint64_t to_uint64( const std::string& i ) { try { try { @@ -117,7 +57,7 @@ namespace fc { FC_RETHROW_EXCEPTIONS( warn, "${i} => uint64_t", ("i",i) ) } FC_CAPTURE_AND_RETHROW( (i) ) } - double to_double( const fc::string& i) + double to_double( const std::string& i) { try { @@ -130,7 +70,7 @@ namespace fc { FC_RETHROW_EXCEPTIONS( warn, "${i} => double", ("i",i) ) } - fc::string to_string(double d) + std::string to_string(double d) { // +2 is required to ensure that the double is rounded correctly when read back in. http://docs.oracle.com/cd/E19957-01/806-3568/ncg_goldberg.html std::stringstream ss; @@ -138,27 +78,22 @@ namespace fc { return ss.str(); } - fc::string to_string( uint64_t d) + std::string to_string( uint64_t d) { return boost::lexical_cast(d); } - fc::string to_string( int64_t d) + std::string to_string( int64_t d) { return boost::lexical_cast(d); } - fc::string to_string( uint16_t d) + std::string to_string( uint16_t d) { return boost::lexical_cast(d); } std::string trim( const std::string& s ) { return boost::algorithm::trim_copy(s); - /* - std::string cpy(s); - boost::algorithm::trim(cpy); - return cpy; - */ } std::string to_lower( const std::string& s ) { @@ -314,5 +249,3 @@ namespace fc { } } // namespace fc - - diff --git a/src/thread/thread.cpp b/src/thread/thread.cpp index f1c1e99..0d1a9aa 100644 --- a/src/thread/thread.cpp +++ b/src/thread/thread.cpp @@ -1,5 +1,4 @@ #include -#include #include #include #include "thread_d.hpp" @@ -136,7 +135,7 @@ namespace fc { return my->name; } - void thread::set_name( const fc::string& n ) + void thread::set_name( const std::string& n ) { if (!is_current()) { @@ -154,7 +153,7 @@ namespace fc { return NULL; } - void thread::debug( const fc::string& d ) { /*my->debug(d);*/ } + void thread::debug( const std::string& d ) { /*my->debug(d);*/ } void thread::quit() { @@ -360,12 +359,12 @@ namespace fc { int wait_any( std::vector&& v, const microseconds& timeout_us ) { - return thread::current().wait_any_until( fc::move(v), time_point::now() + timeout_us ); + return thread::current().wait_any_until( std::move(v), time_point::now() + timeout_us ); } int wait_any_until( std::vector&& v, const time_point& tp ) { - return thread::current().wait_any_until( fc::move(v), tp ); + return thread::current().wait_any_until( std::move(v), tp ); } void thread::wait_until( promise_base::ptr&& p, const time_point& timeout ) diff --git a/src/thread/thread_d.hpp b/src/thread/thread_d.hpp index c11403a..5353606 100644 --- a/src/thread/thread_d.hpp +++ b/src/thread/thread_d.hpp @@ -1,5 +1,4 @@ #include -#include #include #include #include "context.hpp" @@ -46,7 +45,7 @@ namespace fc { #endif { static boost::atomic cnt(0); - name = fc::string("th_") + char('a'+cnt++); + name = std::string("th_") + char('a'+cnt++); // printf("thread=%p\n",this); } @@ -93,7 +92,7 @@ namespace fc { std::vector free_list; // list of unused contexts that are ready for deletion bool done; - fc::string name; + std::string name; fc::context* current; // the currently-executing task in this thread fc::context* pt_head; // list of contexts that can be reused for new tasks @@ -117,7 +116,7 @@ namespace fc { #endif #if 0 - void debug( const fc::string& s ) { + void debug( const std::string& s ) { return; //boost::unique_lock lock(log_mutex()); diff --git a/src/time.cpp b/src/time.cpp index bf8857f..9be1416 100644 --- a/src/time.cpp +++ b/src/time.cpp @@ -3,7 +3,6 @@ #include #include #include -#include #include #include @@ -16,24 +15,24 @@ namespace fc { return time_point( microseconds( bch::duration_cast( bch::system_clock::now().time_since_epoch() ).count() ) ); } - fc::string time_point_sec::to_non_delimited_iso_string()const + std::string time_point_sec::to_non_delimited_iso_string()const { const auto ptime = boost::posix_time::from_time_t( time_t( sec_since_epoch() ) ); return boost::posix_time::to_iso_string( ptime ); } - fc::string time_point_sec::to_iso_string()const + std::string time_point_sec::to_iso_string()const { const auto ptime = boost::posix_time::from_time_t( time_t( sec_since_epoch() ) ); return boost::posix_time::to_iso_extended_string( ptime ); } - time_point_sec::operator fc::string()const + time_point_sec::operator std::string()const { return this->to_iso_string(); } - time_point_sec time_point_sec::from_iso_string( const fc::string& s ) + time_point_sec time_point_sec::from_iso_string( const std::string& s ) { try { static boost::posix_time::ptime epoch = boost::posix_time::from_time_t( 0 ); boost::posix_time::ptime pt; @@ -44,24 +43,24 @@ namespace fc { return fc::time_point_sec( (pt - epoch).total_seconds() ); } FC_RETHROW_EXCEPTIONS( warn, "unable to convert ISO-formatted string to fc::time_point_sec" ) } - time_point::operator fc::string()const + time_point::operator std::string()const { - return fc::string( time_point_sec( *this ) ); + return std::string( time_point_sec( *this ) ); } - time_point time_point::from_iso_string( const fc::string& s ) + time_point time_point::from_iso_string( const std::string& s ) { try { return time_point( time_point_sec::from_iso_string( s ) ); } FC_RETHROW_EXCEPTIONS( warn, "unable to convert ISO-formatted string to fc::time_point" ) } void to_variant( const fc::time_point& t, variant& v, uint32_t max_depth ) { - to_variant( fc::string( t ), v, max_depth ); + to_variant( std::string( t ), v, max_depth ); } void from_variant( const fc::variant& v, fc::time_point& t, uint32_t max_depth ) { t = fc::time_point::from_iso_string( v.as_string() ); } void to_variant( const fc::time_point_sec& t, variant& v, uint32_t max_depth ) { - to_variant( fc::string( t ), v, max_depth ); + to_variant( std::string( t ), v, max_depth ); } void from_variant( const fc::variant& v, fc::time_point_sec& t, uint32_t max_depth ) { t = fc::time_point_sec::from_iso_string( v.as_string() ); diff --git a/src/variant.cpp b/src/variant.cpp index 2ee8256..74afb1d 100644 --- a/src/variant.cpp +++ b/src/variant.cpp @@ -140,31 +140,31 @@ variant::variant( const wchar_t* str, uint32_t max_depth ) set_variant_type( this, string_type ); } -variant::variant( fc::string val, uint32_t max_depth ) +variant::variant( std::string val, uint32_t max_depth ) { - *reinterpret_cast(this) = new string( fc::move(val) ); + *reinterpret_cast(this) = new string( std::move(val) ); set_variant_type( this, string_type ); } variant::variant( blob val, uint32_t max_depth ) { - *reinterpret_cast(this) = new blob( fc::move(val) ); + *reinterpret_cast(this) = new blob( std::move(val) ); set_variant_type( this, blob_type ); } variant::variant( variant_object obj, uint32_t max_depth ) { - *reinterpret_cast(this) = new variant_object(fc::move(obj)); + *reinterpret_cast(this) = new variant_object(std::move(obj)); set_variant_type(this, object_type ); } variant::variant( mutable_variant_object obj, uint32_t max_depth ) { - *reinterpret_cast(this) = new variant_object(fc::move(obj)); + *reinterpret_cast(this) = new variant_object(std::move(obj)); set_variant_type(this, object_type ); } variant::variant( variants arr, uint32_t max_depth ) { - *reinterpret_cast(this) = new variants(fc::move(arr)); + *reinterpret_cast(this) = new variants(std::move(arr)); set_variant_type(this, array_type ); } @@ -647,7 +647,7 @@ void from_variant( const variant& var, float& vo, uint32_t max_depth ) void to_variant( const std::string& s, variant& v, uint32_t max_depth ) { - v = variant( fc::string(s), max_depth ); + v = variant( std::string(s), max_depth ); } void from_variant( const variant& var, string& vo, uint32_t max_depth ) diff --git a/src/variant_object.cpp b/src/variant_object.cpp index 652fddd..cfc913f 100644 --- a/src/variant_object.cpp +++ b/src/variant_object.cpp @@ -9,8 +9,8 @@ namespace fc // entry variant_object::entry::entry() {} - variant_object::entry::entry( string k, variant v ) : _key(fc::move(k)),_value(fc::move(v)) {} - variant_object::entry::entry( entry&& e ) : _key(fc::move(e._key)),_value(fc::move(e._value)) {} + variant_object::entry::entry( string k, variant v ) : _key(std::move(k)),_value(std::move(v)) {} + variant_object::entry::entry( entry&& e ) : _key(std::move(e._key)),_value(std::move(e._value)) {} variant_object::entry::entry( const entry& e ) : _key(e._key),_value(e._value) {} variant_object::entry& variant_object::entry::operator=( const variant_object::entry& e ) { @@ -23,8 +23,8 @@ namespace fc } variant_object::entry& variant_object::entry::operator=( variant_object::entry&& e ) { - fc_swap( _key, e._key ); - fc_swap( _value, e._value ); + std::swap( _key, e._key ); + std::swap( _value, e._value ); return *this; } @@ -44,7 +44,7 @@ namespace fc void variant_object::entry::set( variant v ) { - fc_swap( _value, v ); + std::swap( _value, v ); } // --------------------------------------------------------------- @@ -103,7 +103,7 @@ namespace fc variant_object::variant_object( string key, variant val ) : _key_value(std::make_shared>()) { - _key_value->emplace_back(entry(fc::move(key), fc::move(val))); + _key_value->emplace_back(entry(std::move(key), std::move(val))); } variant_object::variant_object( const variant_object& obj ) @@ -113,7 +113,7 @@ namespace fc } variant_object::variant_object( variant_object&& obj) - : _key_value( fc::move(obj._key_value) ) + : _key_value( std::move(obj._key_value) ) { obj._key_value = std::make_shared>(); assert( _key_value != nullptr ); @@ -125,7 +125,7 @@ namespace fc } variant_object::variant_object( mutable_variant_object&& obj ) - : _key_value(fc::move(obj._key_value)) + : _key_value(std::move(obj._key_value)) { assert( _key_value != nullptr ); } @@ -134,7 +134,7 @@ namespace fc { if (this != &obj) { - fc_swap(_key_value, obj._key_value ); + std::swap(_key_value, obj._key_value ); assert( _key_value != nullptr ); } return *this; @@ -151,7 +151,7 @@ namespace fc variant_object& variant_object::operator=( mutable_variant_object&& obj ) { - _key_value = fc::move(obj._key_value); + _key_value = std::move(obj._key_value); obj._key_value.reset( new std::vector() ); return *this; } @@ -266,7 +266,7 @@ namespace fc mutable_variant_object::mutable_variant_object( string key, variant val ) : _key_value(new std::vector()) { - _key_value->push_back(entry(fc::move(key), fc::move(val))); + _key_value->push_back(entry(std::move(key), std::move(val))); } mutable_variant_object::mutable_variant_object( const variant_object& obj ) @@ -280,7 +280,7 @@ namespace fc } mutable_variant_object::mutable_variant_object( mutable_variant_object&& obj ) - : _key_value(fc::move(obj._key_value)) + : _key_value(std::move(obj._key_value)) { } @@ -294,7 +294,7 @@ namespace fc { if (this != &obj) { - _key_value = fc::move(obj._key_value); + _key_value = std::move(obj._key_value); } return *this; } @@ -331,11 +331,11 @@ namespace fc auto itr = find( key.c_str() ); if( itr != end() ) { - itr->set( fc::move(var) ); + itr->set( std::move(var) ); } else { - _key_value->push_back( entry( fc::move(key), fc::move(var) ) ); + _key_value->push_back( entry( std::move(key), std::move(var) ) ); } return *this; } @@ -345,7 +345,7 @@ namespace fc */ mutable_variant_object& mutable_variant_object::operator()( string key, variant var, uint32_t max_depth ) { - _key_value->push_back( entry( fc::move(key), fc::move(var) ) ); + _key_value->push_back( entry( std::move(key), std::move(var) ) ); return *this; } diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt index 17c8e5f..95d7242 100644 --- a/tests/CMakeLists.txt +++ b/tests/CMakeLists.txt @@ -1,7 +1,4 @@ -add_executable( bip_lock bip_lock.cpp ) -target_link_libraries( bip_lock fc ) - add_executable( api api.cpp ) target_link_libraries( api fc ) diff --git a/tests/bip_lock.cpp b/tests/bip_lock.cpp deleted file mode 100644 index 38bf684..0000000 --- a/tests/bip_lock.cpp +++ /dev/null @@ -1,44 +0,0 @@ -#include -#include -#include -#include -#include - -int main( int argc, char** argv ) { - if( argc < 2 ) return 0; - fc::file_mutex m( argv[1] ); - auto mptr = &m; - - fc::thread in("in"); - - std::string cmd; - std::cout << ">>> "; - std::cin >> cmd; - int i = 0; - while( !std::cin.eof() && cmd != "q" ) { - ++i; - fc::async( [i, cmd,mptr]() { - ilog( "start ${c} ${i}", ("c",cmd)("i",i) ); - if( cmd == "L" ) { - mptr->lock(); - } else if( cmd == "l" ) { - mptr->lock_shared(); - } else if( cmd == "U" ) { - mptr->unlock(); - } else if( cmd == "u" ) { - mptr->unlock_shared(); - } - ilog( "end ${c} ${i}", ("c",cmd)("i",i) ); - } ); - fc::usleep( fc::microseconds( 1000 ) ); - cmd = in.async( [&]() { - std::string tmp; - wdump((m.readers())); - std::cin >> tmp; - return tmp; - } ); - } - std::cout << "done"; - - return 0; -} diff --git a/tests/crypto/base_n_tests.cpp b/tests/crypto/base_n_tests.cpp index 9df7b91..97786a1 100644 --- a/tests/crypto/base_n_tests.cpp +++ b/tests/crypto/base_n_tests.cpp @@ -17,8 +17,8 @@ static const std::string TEST5("\0\0\0", 3); static void test_16( const std::string& test, const std::string& expected ) { std::vector vec( test.begin(), test.end() ); - fc::string enc1 = fc::to_hex( vec ); - fc::string enc2 = fc::to_hex( test.c_str(), test.size() ); + std::string enc1 = fc::to_hex( vec ); + std::string enc2 = fc::to_hex( test.c_str(), test.size() ); BOOST_CHECK_EQUAL( enc1, enc2 ); BOOST_CHECK_EQUAL( expected, enc2 ); @@ -46,8 +46,8 @@ BOOST_AUTO_TEST_CASE(hex_test) static void test_36( const std::string& test, const std::string& expected ) { std::vector vec( test.begin(), test.end() ); - fc::string enc1 = fc::to_base36( vec ); - fc::string enc2 = fc::to_base36( test.c_str(), test.size() ); + std::string enc1 = fc::to_base36( vec ); + std::string enc2 = fc::to_base36( test.c_str(), test.size() ); BOOST_CHECK_EQUAL( enc1, enc2 ); BOOST_CHECK_EQUAL( expected, enc2 ); @@ -69,8 +69,8 @@ BOOST_AUTO_TEST_CASE(base36_test) static void test_58( const std::string& test, const std::string& expected ) { std::vector vec( test.begin(), test.end() ); - fc::string enc1 = fc::to_base58( vec ); - fc::string enc2 = fc::to_base58( test.c_str(), test.size() ); + std::string enc1 = fc::to_base58( vec ); + std::string enc2 = fc::to_base58( test.c_str(), test.size() ); BOOST_CHECK_EQUAL( enc1, enc2 ); BOOST_CHECK_EQUAL( expected, enc2 ); @@ -100,8 +100,8 @@ BOOST_AUTO_TEST_CASE(base58_test) static void test_64( const std::string& test, const std::string& expected ) { - fc::string enc1 = fc::base64_encode( test ); - fc::string enc2 = fc::base64_encode( test.c_str(), test.size() ); + std::string enc1 = fc::base64_encode( test ); + std::string enc2 = fc::base64_encode( test.c_str(), test.size() ); BOOST_CHECK_EQUAL( enc1, enc2 ); BOOST_CHECK_EQUAL( expected, enc2 ); diff --git a/tests/hmac_test.cpp b/tests/hmac_test.cpp index 140b211..ea3e54b 100644 --- a/tests/hmac_test.cpp +++ b/tests/hmac_test.cpp @@ -9,63 +9,63 @@ // See http://tools.ietf.org/html/rfc4231 -static const fc::string TEST1_KEY = "0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b"; -static const fc::string TEST1_DATA = "4869205468657265"; -static const fc::string TEST1_224 = "896fb1128abbdf196832107cd49df33f47b4b1169912ba4f53684b22"; -static const fc::string TEST1_256 = "b0344c61d8db38535ca8afceaf0bf12b881dc200c9833da726e9376c2e32cff7"; -static const fc::string TEST1_512 = "87aa7cdea5ef619d4ff0b4241a1d6cb02379f4e2ce4ec2787ad0b30545e17cde" +static const std::string TEST1_KEY = "0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b"; +static const std::string TEST1_DATA = "4869205468657265"; +static const std::string TEST1_224 = "896fb1128abbdf196832107cd49df33f47b4b1169912ba4f53684b22"; +static const std::string TEST1_256 = "b0344c61d8db38535ca8afceaf0bf12b881dc200c9833da726e9376c2e32cff7"; +static const std::string TEST1_512 = "87aa7cdea5ef619d4ff0b4241a1d6cb02379f4e2ce4ec2787ad0b30545e17cde" "daa833b7d6b8a702038b274eaea3f4e4be9d914eeb61f1702e696c203a126854"; -static const fc::string TEST2_KEY = "4a656665"; -static const fc::string TEST2_DATA = "7768617420646f2079612077616e7420666f72206e6f7468696e673f"; -static const fc::string TEST2_224 = "a30e01098bc6dbbf45690f3a7e9e6d0f8bbea2a39e6148008fd05e44"; -static const fc::string TEST2_256 = "5bdcc146bf60754e6a042426089575c75a003f089d2739839dec58b964ec3843"; -static const fc::string TEST2_512 = "164b7a7bfcf819e2e395fbe73b56e0a387bd64222e831fd610270cd7ea250554" +static const std::string TEST2_KEY = "4a656665"; +static const std::string TEST2_DATA = "7768617420646f2079612077616e7420666f72206e6f7468696e673f"; +static const std::string TEST2_224 = "a30e01098bc6dbbf45690f3a7e9e6d0f8bbea2a39e6148008fd05e44"; +static const std::string TEST2_256 = "5bdcc146bf60754e6a042426089575c75a003f089d2739839dec58b964ec3843"; +static const std::string TEST2_512 = "164b7a7bfcf819e2e395fbe73b56e0a387bd64222e831fd610270cd7ea250554" "9758bf75c05a994a6d034f65f8f0e6fdcaeab1a34d4a6b4b636e070a38bce737"; -static const fc::string TEST3_KEY = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"; -static const fc::string TEST3_DATA = "dddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd" +static const std::string TEST3_KEY = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"; +static const std::string TEST3_DATA = "dddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd" "dddddddddddddddddddddddddddddddddddd"; -static const fc::string TEST3_224 = "7fb3cb3588c6c1f6ffa9694d7d6ad2649365b0c1f65d69d1ec8333ea"; -static const fc::string TEST3_256 = "773ea91e36800e46854db8ebd09181a72959098b3ef8c122d9635514ced565fe"; -static const fc::string TEST3_512 = "fa73b0089d56a284efb0f0756c890be9b1b5dbdd8ee81a3655f83e33b2279d39" +static const std::string TEST3_224 = "7fb3cb3588c6c1f6ffa9694d7d6ad2649365b0c1f65d69d1ec8333ea"; +static const std::string TEST3_256 = "773ea91e36800e46854db8ebd09181a72959098b3ef8c122d9635514ced565fe"; +static const std::string TEST3_512 = "fa73b0089d56a284efb0f0756c890be9b1b5dbdd8ee81a3655f83e33b2279d39" "bf3e848279a722c806b485a47e67c807b946a337bee8942674278859e13292fb"; -static const fc::string TEST4_KEY = "0102030405060708090a0b0c0d0e0f10111213141516171819"; -static const fc::string TEST4_DATA = "cdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcd" +static const std::string TEST4_KEY = "0102030405060708090a0b0c0d0e0f10111213141516171819"; +static const std::string TEST4_DATA = "cdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcd" "cdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcd"; -static const fc::string TEST4_224 = "6c11506874013cac6a2abc1bb382627cec6a90d86efc012de7afec5a"; -static const fc::string TEST4_256 = "82558a389a443c0ea4cc819899f2083a85f0faa3e578f8077a2e3ff46729665b"; -static const fc::string TEST4_512 = "b0ba465637458c6990e5a8c5f61d4af7e576d97ff94b872de76f8050361ee3db" +static const std::string TEST4_224 = "6c11506874013cac6a2abc1bb382627cec6a90d86efc012de7afec5a"; +static const std::string TEST4_256 = "82558a389a443c0ea4cc819899f2083a85f0faa3e578f8077a2e3ff46729665b"; +static const std::string TEST4_512 = "b0ba465637458c6990e5a8c5f61d4af7e576d97ff94b872de76f8050361ee3db" "a91ca5c11aa25eb4d679275cc5788063a5f19741120c4f2de2adebeb10a298dd"; // test 5 skipped - truncated -static const fc::string TEST6_KEY = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" +static const std::string TEST6_KEY = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" "aaaaaa"; -static const fc::string TEST6_DATA = "54657374205573696e67204c6172676572205468616e20426c6f636b2d53697a" +static const std::string TEST6_DATA = "54657374205573696e67204c6172676572205468616e20426c6f636b2d53697a" "65204b6579202d2048617368204b6579204669727374"; -static const fc::string TEST6_224 = "95e9a0db962095adaebe9b2d6f0dbce2d499f112f2d2b7273fa6870e"; -static const fc::string TEST6_256 = "60e431591ee0b67f0d8a26aacbf5b77f8e0bc6213728c5140546040f0ee37f54"; -static const fc::string TEST6_512 = "80b24263c7c1a3ebb71493c1dd7be8b49b46d1f41b4aeec1121b013783f8f352" +static const std::string TEST6_224 = "95e9a0db962095adaebe9b2d6f0dbce2d499f112f2d2b7273fa6870e"; +static const std::string TEST6_256 = "60e431591ee0b67f0d8a26aacbf5b77f8e0bc6213728c5140546040f0ee37f54"; +static const std::string TEST6_512 = "80b24263c7c1a3ebb71493c1dd7be8b49b46d1f41b4aeec1121b013783f8f352" "6b56d037e05f2598bd0fd2215d6a1e5295e64f73f63f0aec8b915a985d786598"; -static const fc::string TEST7_KEY = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" +static const std::string TEST7_KEY = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" "aaaaaa"; -static const fc::string TEST7_DATA = "5468697320697320612074657374207573696e672061206c6172676572207468" +static const std::string TEST7_DATA = "5468697320697320612074657374207573696e672061206c6172676572207468" "616e20626c6f636b2d73697a65206b657920616e642061206c61726765722074" "68616e20626c6f636b2d73697a6520646174612e20546865206b6579206e6565" "647320746f20626520686173686564206265666f7265206265696e6720757365" "642062792074686520484d414320616c676f726974686d2e"; -static const fc::string TEST7_224 = "3a854166ac5d9f023f54d517d0b39dbd946770db9c2b95c9f6f565d1"; -static const fc::string TEST7_256 = "9b09ffa71b942fcb27635fbcd5b0e944bfdc63644f0713938a7f51535c3a35e2"; -static const fc::string TEST7_512 = "e37b6a775dc87dbaa4dfa9f96e5e3ffddebd71f8867289865df5a32d20cdc944" +static const std::string TEST7_224 = "3a854166ac5d9f023f54d517d0b39dbd946770db9c2b95c9f6f565d1"; +static const std::string TEST7_256 = "9b09ffa71b942fcb27635fbcd5b0e944bfdc63644f0713938a7f51535c3a35e2"; +static const std::string TEST7_512 = "e37b6a775dc87dbaa4dfa9f96e5e3ffddebd71f8867289865df5a32d20cdc944" "b6022cac3c4982b10d5eeb55c3e4de15134676fb6de0446065c97440fa8c6a58"; static fc::hmac mac_224; @@ -73,8 +73,8 @@ static fc::hmac mac_256; static fc::hmac mac_512; template -static void run_test( const fc::string& key, const fc::string& data, const fc::string& expect_224, - const fc::string& expect_256, const fc::string& expect_512 ) +static void run_test( const std::string& key, const std::string& data, const std::string& expect_224, + const std::string& expect_256, const std::string& expect_512 ) { fc::array key_arr; diff --git a/tests/io/stream_tests.cpp b/tests/io/stream_tests.cpp index e3f3dc8..359ec9d 100644 --- a/tests/io/stream_tests.cpp +++ b/tests/io/stream_tests.cpp @@ -12,8 +12,8 @@ BOOST_AUTO_TEST_SUITE(stream_tests) BOOST_AUTO_TEST_CASE(stringstream_test) { - const fc::string constant( "Hello", 6 ); // includes trailing \0 - fc::string writable( "World" ); + const std::string constant( "Hello", 6 ); // includes trailing \0 + std::string writable( "World" ); fc::stringstream in1( constant ); fc::stringstream in2( writable ); fc::stringstream out; @@ -44,8 +44,8 @@ BOOST_AUTO_TEST_CASE(stringstream_test) BOOST_AUTO_TEST_CASE(buffered_stringstream_test) { - const fc::string constant( "Hello", 6 ); // includes trailing \0 - fc::string writable( "World" ); + const std::string constant( "Hello", 6 ); // includes trailing \0 + std::string writable( "World" ); fc::istream_ptr in1( new fc::stringstream( constant ) ); std::shared_ptr in2( new fc::stringstream( writable ) ); std::shared_ptr out1( new fc::stringstream() ); diff --git a/tests/logging_tests.cpp b/tests/logging_tests.cpp index 659c80d..ef66501 100644 --- a/tests/logging_tests.cpp +++ b/tests/logging_tests.cpp @@ -46,7 +46,7 @@ BOOST_AUTO_TEST_CASE(log_reboot) int64_t interval_seconds = conf.rotation_interval.to_seconds(); int64_t file_number = now.sec_since_epoch() / interval_seconds; fc::time_point_sec start_time = fc::time_point_sec( (uint32_t)(file_number * interval_seconds) ); - fc::string timestamp_string = start_time.to_non_delimited_iso_string(); + std::string timestamp_string = start_time.to_non_delimited_iso_string(); fc::path link_filename = conf.filename; fc::path log_filename = link_filename.parent_path() / (link_filename.filename().string() + "." + timestamp_string);