From b07aed4a2236180527756ead2445472710677f42 Mon Sep 17 00:00:00 2001 From: Daniel Larimer Date: Thu, 27 Jun 2013 14:19:08 -0400 Subject: [PATCH] Update use of fc::string and fc::vector. --- CMakeLists.txt | 11 +- include/fc/crypto/base32.hpp | 4 +- include/fc/crypto/base36.hpp | 4 +- include/fc/crypto/bigint.hpp | 4 +- include/fc/crypto/dh.hpp | 12 +- include/fc/interprocess/iprocess.hpp | 5 +- include/fc/interprocess/process.hpp | 2 +- include/fc/log/appender.hpp | 2 +- include/fc/log/console_appender.hpp | 2 +- include/fc/log/log_message.hpp | 2 +- include/fc/log/logger_config.hpp | 8 +- include/fc/network/http/connection.hpp | 12 +- include/fc/signal.hpp | 93 ++++-- include/fc/ssh/process.hpp | 2 +- include/fc/string.hpp | 20 ++ include/fc/thread/thread.hpp | 12 +- include/fc/thread/wait_condition.hpp | 14 +- include/fc/variant.hpp | 17 +- include/fc/variant_object.hpp | 22 +- include/fc/vector.hpp | 401 +------------------------ src/crypto/base36.cpp | 6 +- src/crypto/base58.cpp | 4 +- src/crypto/bigint.cpp | 8 +- src/crypto/dh.cpp | 2 +- src/crypto/sha256.cpp | 4 +- src/interprocess/process.cpp | 8 +- src/io/iostream.cpp | 5 +- src/log/logger.cpp | 2 +- src/network/http/http_connection.cpp | 8 +- src/network/resolve.cpp | 4 +- src/string.cpp | 2 + src/thread/thread.cpp | 6 +- src/variant.cpp | 6 +- src/variant_object.cpp | 18 +- 34 files changed, 199 insertions(+), 533 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 7b0db49..f37482e 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -61,11 +61,7 @@ include_directories( vendor/boost_1.51/include ) include_directories( ${Boost_INCLUDE_DIR} ) include_directories( ${OPENSSL_INCLUDE_DIR} ) -SET( ALL_OPENSSL_LIBRARIES - ${OPENSSL_LIBRARIES} - ${SSL_EAY_RELEASE} - ${LIB_EAY_RELEASE} - ) +SET( ALL_OPENSSL_LIBRARIES ${OPENSSL_LIBRARIES} ${SSL_EAY_RELEASE} ${LIB_EAY_RELEASE}) set( fc_sources src/variant.cpp @@ -99,12 +95,15 @@ set( fc_sources src/log/file_appender.cpp src/log/logger_config.cpp src/crypto/base36.cpp - src/crypto/bigint.cpp + src/crypto/base32.cpp src/crypto/base64.cpp src/crypto/base58.cpp + src/crypto/bigint.cpp src/crypto/hex.cpp src/crypto/sha1.cpp src/crypto/sha256.cpp + src/crypto/sha224.cpp + src/crypto/sha512.cpp src/crypto/dh.cpp src/crypto/blowfish.cpp src/network/tcp_socket.cpp diff --git a/include/fc/crypto/base32.hpp b/include/fc/crypto/base32.hpp index ed81aae..15bf169 100644 --- a/include/fc/crypto/base32.hpp +++ b/include/fc/crypto/base32.hpp @@ -4,7 +4,7 @@ namespace fc { - fc::vector from_base32( const fc::string& b32 ); - fc::string to_base32( const fc::vector& vec ); + std::vector from_base32( const fc::string& b32 ); + fc::string to_base32( const std::vector& vec ); fc::string to_base32( const char* data, size_t len ); } diff --git a/include/fc/crypto/base36.hpp b/include/fc/crypto/base36.hpp index 163dabf..aeb9c35 100644 --- a/include/fc/crypto/base36.hpp +++ b/include/fc/crypto/base36.hpp @@ -4,7 +4,7 @@ namespace fc { - fc::vector from_base36( const fc::string& b36 ); - fc::string to_base36( const fc::vector& vec ); + 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 ); } diff --git a/include/fc/crypto/bigint.hpp b/include/fc/crypto/bigint.hpp index d5e4962..91639d5 100644 --- a/include/fc/crypto/bigint.hpp +++ b/include/fc/crypto/bigint.hpp @@ -9,7 +9,7 @@ typedef bignum_st BIGNUM; namespace fc { class bigint { public: - bigint( const fc::vector& bige ); + bigint( const std::vector& bige ); bigint( const char* bige, uint32_t l ); bigint( unsigned long i = 0 ); bigint( const bigint& c ); @@ -52,7 +52,7 @@ namespace fc { operator fc::string()const; // returns bignum as bigendian bytes - operator fc::vector()const; + operator std::vector()const; BIGNUM* dup()const; diff --git a/include/fc/crypto/dh.hpp b/include/fc/crypto/dh.hpp index 92c63b6..5e6f89f 100644 --- a/include/fc/crypto/dh.hpp +++ b/include/fc/crypto/dh.hpp @@ -1,5 +1,5 @@ #pragma once -#include +#include #include namespace fc { @@ -9,13 +9,13 @@ namespace fc { bool generate_params( int s, uint8_t g ); bool generate_pub_key(); bool compute_shared_key( const char* buf, uint32_t s ); - bool compute_shared_key( const vector& pubk); + bool compute_shared_key( const std::vector& pubk); bool validate(); - vector p; - vector pub_key; - vector priv_key; - vector shared_key; + std::vector p; + std::vector pub_key; + std::vector priv_key; + std::vector shared_key; bool valid; uint8_t g; }; diff --git a/include/fc/interprocess/iprocess.hpp b/include/fc/interprocess/iprocess.hpp index 77d9ce6..3dcbfed 100644 --- a/include/fc/interprocess/iprocess.hpp +++ b/include/fc/interprocess/iprocess.hpp @@ -1,7 +1,7 @@ #pragma once #include #include -#include +#include #include #include @@ -22,6 +22,7 @@ namespace fc open_stdout = 0x02, open_stderr = 0x04, open_all = open_stdin|open_stdout|open_stderr, + suppress_console = 0x08 }; virtual ~iprocess(){} @@ -30,7 +31,7 @@ namespace fc * * @return *this */ - virtual iprocess& exec( const fc::path& exe, vector args, + virtual iprocess& exec( const fc::path& exe, std::vector args, const fc::path& work_dir = fc::path(), exec_opts opts = open_all ) = 0; /** diff --git a/include/fc/interprocess/process.hpp b/include/fc/interprocess/process.hpp index 54813b8..eb13a4a 100644 --- a/include/fc/interprocess/process.hpp +++ b/include/fc/interprocess/process.hpp @@ -16,7 +16,7 @@ namespace fc { ~process(); virtual iprocess& exec( const fc::path& exe, - vector args, + std::vector args, const fc::path& work_dir = fc::path(), exec_opts opts = open_all ); diff --git a/include/fc/log/appender.hpp b/include/fc/log/appender.hpp index 093cce8..f1f5aa8 100644 --- a/include/fc/log/appender.hpp +++ b/include/fc/log/appender.hpp @@ -1,10 +1,10 @@ #pragma once #include +#include namespace fc { class appender; class log_message; - class string; class variant; class appender_factory : public fc::retainable { diff --git a/include/fc/log/console_appender.hpp b/include/fc/log/console_appender.hpp index 9fe9f30..0ff9de0 100644 --- a/include/fc/log/console_appender.hpp +++ b/include/fc/log/console_appender.hpp @@ -41,7 +41,7 @@ namespace fc fc::string format; console_appender::stream::type stream; - fc::vector level_colors; + std::vector level_colors; bool flush; }; diff --git a/include/fc/log/log_message.hpp b/include/fc/log/log_message.hpp index c632cc6..4a6257a 100644 --- a/include/fc/log/log_message.hpp +++ b/include/fc/log/log_message.hpp @@ -127,7 +127,7 @@ namespace fc void to_variant( const log_message& l, variant& v ); void from_variant( const variant& l, log_message& c ); - typedef fc::vector log_messages; + typedef std::vector log_messages; } // namespace fc diff --git a/include/fc/log/logger_config.hpp b/include/fc/log/logger_config.hpp index c46accc..b31fefe 100644 --- a/include/fc/log/logger_config.hpp +++ b/include/fc/log/logger_config.hpp @@ -21,16 +21,16 @@ namespace fc { bool enabled; /// if any appenders are sepecified, then parent's appenders are not set. bool additivity; - fc::vector appenders; + std::vector appenders; logger_config& add_appender( const string& s ); }; struct logging_config { static logging_config default_config(); - fc::vector includes; - fc::vector appenders; - fc::vector loggers; + std::vector includes; + std::vector appenders; + std::vector loggers; }; void configure_logging( const fc::path& log_config ); diff --git a/include/fc/network/http/connection.hpp b/include/fc/network/http/connection.hpp index 90d9090..5918c8a 100644 --- a/include/fc/network/http/connection.hpp +++ b/include/fc/network/http/connection.hpp @@ -18,7 +18,7 @@ namespace fc { fc::string val; }; - typedef fc::vector
headers; + typedef std::vector
headers; struct reply { @@ -31,8 +31,8 @@ namespace fc { }; reply( status_code c = OK):status(c){} int status; - fc::vector
headers; - fc::vector body; + std::vector
headers; + std::vector body; }; struct request @@ -41,11 +41,11 @@ namespace fc { fc::string method; fc::string domain; fc::string path; - fc::vector
headers; - fc::vector body; + std::vector
headers; + std::vector body; }; - fc::vector
parse_urlencoded_params( const fc::string& f ); + std::vector
parse_urlencoded_params( const fc::string& f ); /** * Connections have reference semantics, all copies refer to the same diff --git a/include/fc/signal.hpp b/include/fc/signal.hpp index 9e9b5a8..73c2b7f 100644 --- a/include/fc/signal.hpp +++ b/include/fc/signal.hpp @@ -1,7 +1,10 @@ #pragma once -#include #include +#include +#include #include +#include +#include #ifdef emit #undef emit #endif @@ -10,72 +13,90 @@ namespace fc { template class signal { + private: + typedef std::function func_type; + typedef std::vector> list_type; public: - typedef int64_t connection_id_type; + typedef void* connection_id_type; template connection_id_type connect( Functor&& f ) { - auto c = new std::function( fc::forward(f) ); - _handlers.push_back( c ); - return reinterpret_cast(c); + 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 ) { - for( size_t i = 0; i < _handlers.size(); ++i ) { - (*_handlers[i])( fc::forward(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 ) { - for( size_t i = 0; i < _handlers.size(); ++i ) { - (*_handlers[i])( fc::forward(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 ) { - for( size_t i = 0; i < _handlers.size(); ++i ) { - (*_handlers[i])( fc::forward(arg), fc::forward(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 ) { - for( size_t i = 0; i < _handlers.size(); ++i ) { - (*_handlers[i])( fc::forward(arg), fc::forward(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 ) { - for( size_t i = 0; i < _handlers.size(); ++i ) { - (*_handlers[i])( fc::forward(arg), fc::forward(arg2), fc::forward(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 ) { - for( size_t i = 0; i < _handlers.size(); ++i ) { - (*_handlers[i])( fc::forward(arg), fc::forward(arg2), fc::forward(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 ) { - for( size_t i = 0; i < _handlers.size(); ++i ) { - (*_handlers[i])( fc::forward(args)... ); + list_type handlers = getHandlers(); + for( size_t i = 0; i < handlers.size(); ++i ) { + (*handlers[i])( fc::forward(args)... ); } } template void operator()( Args&&... args ) { - for( size_t i = 0; i < _handlers.size(); ++i ) { - (*_handlers[i])( fc::forward(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) == cid ) { - delete *itr; + if( reinterpret_cast(itr->get()) == cid ) { _handlers.erase(itr); } ++itr; @@ -85,17 +106,25 @@ namespace fc { { _handlers.reserve(4); } - ~signal() - { - for( auto itr = _handlers.begin(); itr != _handlers.end(); ++itr ) - { - delete *itr; - } - _handlers.clear(); - } + //~signal() + //{ + // for( auto itr = _handlers.begin(); itr != _handlers.end(); ++itr ) + // { + // delete *itr; + // } + // _handlers.clear(); + //} private: - fc::vector< std::function* > _handlers; + 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/ssh/process.hpp b/include/fc/ssh/process.hpp index 3f26ead..08eb089 100644 --- a/include/fc/ssh/process.hpp +++ b/include/fc/ssh/process.hpp @@ -19,7 +19,7 @@ namespace fc { namespace ssh class process : public iprocess { public: - virtual iprocess& exec( const fc::path& exe, vector args, + virtual iprocess& exec( const fc::path& exe, std::vector args, const fc::path& work_dir = fc::path(), exec_opts opts = open_all ); /** diff --git a/include/fc/string.hpp b/include/fc/string.hpp index c3798e5..5a53cd9 100644 --- a/include/fc/string.hpp +++ b/include/fc/string.hpp @@ -3,6 +3,25 @@ #include #include +#ifndef USE_FC_STRING +#include +namespace fc +{ + typedef std::string 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 ); + + typedef fc::optional ostring; + class variant_object; + fc::string format_string( const fc::string&, const variant_object& ); +} + +#else /** * There is debate about whether doing this is 'standard conforming', but @@ -120,3 +139,4 @@ namespace fc { } // namespace fc +#endif diff --git a/include/fc/thread/thread.hpp b/include/fc/thread/thread.hpp index ee60c70..eec4f72 100644 --- a/include/fc/thread/thread.hpp +++ b/include/fc/thread/thread.hpp @@ -109,7 +109,7 @@ namespace fc { template int wait_any( const fc::future& f1, const fc::future& f2, const microseconds& timeout_us = microseconds::maximum()) { - fc::vector proms(2); + 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 ); @@ -123,15 +123,15 @@ namespace fc { friend void usleep(const microseconds&); friend void sleep_until(const time_point&); friend void exec(); - friend int wait_any( fc::vector&& v, const microseconds& ); - friend int wait_any_until( fc::vector&& v, const time_point& tp ); + friend int wait_any( std::vector&& v, const microseconds& ); + friend int wait_any_until( std::vector&& v, const time_point& tp ); void wait_until( promise_base::ptr && v, const time_point& tp ); void notify( const promise_base::ptr& v ); void yield(bool reschedule=true); void sleep_until( const time_point& t ); void exec(); - int wait_any_until( fc::vector&& v, const time_point& ); + int wait_any_until( std::vector&& v, const time_point& ); void async_task( task_base* t, const priority& p, const char* desc ); void async_task( task_base* t, const priority& p, const time_point& tp, const char* desc ); @@ -168,8 +168,8 @@ namespace fc { int wait_any( const fc::future& f1, const fc::future& f2, const microseconds timeout_us = microseconds::maximum()) { return fc::thread::current().wait_any(f1,f2,timeout_us); } - int wait_any( fc::vector&& v, const microseconds& timeout_us = microseconds::maximum() ); - int wait_any_until( fc::vector&& v, const time_point& tp ); + int wait_any( std::vector&& v, const microseconds& timeout_us = microseconds::maximum() ); + int wait_any_until( std::vector&& v, const time_point& tp ); template auto async( Functor&& f, const char* desc ="", priority prio = priority()) -> fc::future { diff --git a/include/fc/thread/wait_condition.hpp b/include/fc/thread/wait_condition.hpp index 75670d2..5006f87 100644 --- a/include/fc/thread/wait_condition.hpp +++ b/include/fc/thread/wait_condition.hpp @@ -15,9 +15,11 @@ namespace fc 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(); + typename fc::promise::ptr p = new fc::promise(_name); { synchronized( _prom_lock ) _promises.push_back( p ); } @@ -27,11 +29,16 @@ namespace fc template T wait( LockType& l, const microseconds& timeout = microseconds::maximum() ) { - typename fc::promise::ptr p( new fc::promise()); + 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); } @@ -53,7 +60,7 @@ namespace fc { std::deque::ptr> all; { synchronized( _prom_lock ) - all = fc::move(_promises); + std::swap(all, _promises); } for( auto itr = all.begin(); itr != all.end(); ++itr ) { @@ -64,5 +71,6 @@ namespace fc private: fc::spin_yield_lock _prom_lock; std::deque::ptr> _promises; + const char *const _name; }; } diff --git a/include/fc/variant.hpp b/include/fc/variant.hpp index 896a79d..c74d291 100644 --- a/include/fc/variant.hpp +++ b/include/fc/variant.hpp @@ -1,8 +1,9 @@ #pragma once -#include #include #include #include +#include +#include namespace fc { @@ -35,8 +36,8 @@ namespace fc void from_variant( const variant& var, variant_object& vo ); void to_variant( const mutable_variant_object& var, variant& vo ); void from_variant( const variant& var, mutable_variant_object& vo ); - void to_variant( const vector& var, variant& vo ); - void from_variant( const variant& var, vector& vo ); + void to_variant( const std::vector& var, variant& vo ); + void from_variant( const variant& var, std::vector& vo ); void to_variant( const time_point& var, variant& vo ); void from_variant( const variant& var, time_point& vo ); #ifdef __APPLE__ @@ -50,10 +51,10 @@ namespace fc template void from_variant( const variant& var, std::shared_ptr& vo ); - typedef vector variants; + typedef std::vector variants; /** - * @brief stores null, int64, uint64, double, bool, string, vector, + * @brief stores null, int64, uint64, double, bool, string, std::vector, * and variant_object's. * * variant's allocate everything but strings, arrays, and objects on the @@ -246,7 +247,7 @@ namespace fc /** @ingroup Serializable */ template - void from_variant( const variant& var, vector& tmp ) + void from_variant( const variant& var, std::vector& tmp ) { const variants& vars = var.get_array(); tmp.clear(); @@ -257,9 +258,9 @@ namespace fc /** @ingroup Serializable */ template - void to_variant( const vector& t, variant& v ) + void to_variant( const std::vector& t, variant& v ) { - vector vars(t.size()); + std::vector vars(t.size()); for( size_t i = 0; i < t.size(); ++i ) vars[i] = variant(t[i]); v = vars; diff --git a/include/fc/variant_object.hpp b/include/fc/variant_object.hpp index a5942ce..32d8e83 100644 --- a/include/fc/variant_object.hpp +++ b/include/fc/variant_object.hpp @@ -43,7 +43,7 @@ namespace fc variant _value; }; - typedef vector< entry >::const_iterator iterator; + typedef std::vector< entry >::const_iterator iterator; /** * @name Immutable Interface @@ -69,9 +69,9 @@ namespace fc template variant_object( string key, T&& val ) - :_key_value( std::make_shared >() ) + :_key_value( std::make_shared >() ) { - *this = variant_object( move(key), variant(forward(val)) ); + *this = variant_object( std::move(key), variant(forward(val)) ); } variant_object( const variant_object& ); variant_object( variant_object&& ); @@ -86,7 +86,7 @@ namespace fc variant_object& operator=( const mutable_variant_object& ); private: - std::shared_ptr< vector< entry > > _key_value; + std::shared_ptr< std::vector< entry > > _key_value; friend class mutable_variant_object; }; /** @ingroup Serializable */ @@ -112,8 +112,8 @@ namespace fc /** @brief a key/value pair */ typedef variant_object::entry entry; - typedef vector< entry >::iterator iterator; - typedef vector< entry >::const_iterator const_iterator; + typedef std::vector< entry >::iterator iterator; + typedef std::vector< entry >::const_iterator const_iterator; /** * @name Immutable Interface @@ -173,7 +173,7 @@ namespace fc template mutable_variant_object& operator()( string key, T&& var ) { - set(move(key), variant( forward(var) ) ); + set(std::move(key), variant( forward(var) ) ); return *this; } ///@} @@ -181,7 +181,7 @@ namespace fc template explicit mutable_variant_object( T&& v ) - :_key_value( new vector() ) + :_key_value( new std::vector() ) { *this = variant(fc::forward(v)).get_object(); } @@ -192,9 +192,9 @@ namespace fc mutable_variant_object( string key, variant val ); template mutable_variant_object( string key, T&& val ) - :_key_value( new vector() ) + :_key_value( new std::vector() ) { - set( move(key), variant(forward(val)) ); + set( std::move(key), variant(forward(val)) ); } mutable_variant_object( mutable_variant_object&& ); @@ -205,7 +205,7 @@ namespace fc mutable_variant_object& operator=( const mutable_variant_object& ); mutable_variant_object& operator=( const variant_object& ); private: - std::unique_ptr< vector< entry > > _key_value; + std::unique_ptr< std::vector< entry > > _key_value; friend class variant_object; }; /** @ingroup Serializable */ diff --git a/include/fc/vector.hpp b/include/fc/vector.hpp index 9220777..d45f384 100644 --- a/include/fc/vector.hpp +++ b/include/fc/vector.hpp @@ -1,402 +1,3 @@ #pragma once -#include -#include -#include -#include - - -namespace fc { - namespace detail { - template - struct data { - size_t size; - size_t capacity; - T first; - - static data* allocate( size_t cap ) { - data* d = nullptr; - if( cap ){ - d = (data*)malloc(sizeof(data) + sizeof(T)*(static_cast(cap)-1)); - d->capacity = static_cast(cap); - } else { - d = (data*)malloc(sizeof(data)); - d->capacity = 1; - } - d->size = 0; - return d; - } - static data* reallocate( data* d, size_t cap ) { - if( cap ){ - d = (data*)realloc(d,sizeof(data) + sizeof(T)*(static_cast(cap)-1)); - d->capacity = static_cast(cap); - } else { - d = (data*)realloc(d,sizeof(data)); - d->capacity = 1; - } - if( d->size > d->capacity ) - d->size = d->capacity; - return d; - } - private: - data(){}; - }; - - template - struct vector_impl { - public: - typedef T* iterator; - typedef const T* const_iterator; - vector_impl():_data(nullptr){} - vector_impl( vector_impl&& c):_data(c._data){c._data =nullptr; } - vector_impl( const vector_impl& c):_data(nullptr) { - if( c.size() ) { - _data = detail::data::allocate( c.size() ); - _data->size = c.size(); - memcpy(begin(),c.begin(), static_cast(c.size()) ); - } - } - vector_impl(const_iterator b, const_iterator e ):_data(nullptr) { - resize(e-b); - if( size() ) memcpy( data(), b, static_cast(size()) ); - } - vector_impl(size_t s):_data(nullptr){ - resize(s); - } - ~vector_impl() { - clear(); - } - - - size_t size()const { return _data ? _data->size : 0; } - size_t capacity()const { return _data ? _data->capacity : 0; } - - T& back() { return (&_data->first)[-1+_data->size]; } - const T& back()const { return (&_data->first)[-1+_data->size]; } - T& front() { return (&_data->first)[0]; } - const T& front()const { return (&_data->first)[0]; } - const T* data()const { return (&_data->first); } - T* data() { return (&_data->first); } - - iterator begin() { return _data ? &front() : 0;} - const_iterator begin()const { return _data ? &front() : 0;} - iterator end() { return _data ? (&back())+1: 0;} - const_iterator end()const { return _data ? (&back())+1: 0;} - - T& operator[]( size_t i ) { return (&_data->first)[i]; } - const T& operator[]( size_t i )const { return (&_data->first)[i]; } - - T& at( size_t i ) { return (&_data->first)[i]; } - const T& at( size_t i )const { return (&_data->first)[i]; } - - void pop_back() { erase( &back() ); } - - void clear() { - if( _data != nullptr ) { - free(_data); - } - _data = nullptr; - } - - void reserve( size_t i ) { - if( nullptr == _data ) - { - _data = detail::data::allocate( i ); - _data->size = 0; - _data->capacity = i; - } - else - { - _data = detail::data::reallocate( _data, i ); - } - } - - void resize( size_t i ) { - if( capacity() < i ) { - if( _data ) - _data = detail::data::reallocate( _data, i ); - else - _data = detail::data::allocate( i ); - } - if( _data ) _data->size = i; - } - - template - void push_back( U&& v ) { - resize( size()+1 ); - back() = fc::forward(v); - } - template - void emplace_back( U&& v ) { - resize( size()+1 ); - back() = fc::forward(v); - } - - template - iterator insert( const_iterator loc, U&& t ) { - size_t pos = loc - begin(); - resize( size()+1 ); - char* src = &at(pos); - if( src != &back() ) - memmove( src+1, src, (&back() - src) ); - &back = fc::forward(t); - return &at(pos); - } - - iterator insert( iterator pos, const_iterator first, const_iterator last ) { - if( first >= last ) return pos; - - size_t loc = pos - begin(); - size_t right_size = size() - loc; - resize( size() + (last-first) ); - char* src = &at(loc); - size_t s = last-first; - memmove( src + s, src, right_size ); - memcpy( src, first, s ); - _data->size += (last-first); - return src; - } - - iterator erase( iterator pos ) { - memmove( pos, pos+1, (&back() - pos) ); - _data->size--; - return pos; - } - - iterator erase( iterator first, iterator last ) { - if( first != last ) { - memmove( first, first + (last-first), (&back() - last) ); - _data->size -= last-first; - } - return first; - } - - vector_impl& operator=( vector_impl&& v ) { - fc_swap(_data,v._data); - return *this; - } - vector_impl& operator=( const vector_impl& v ) { - vector_impl tmp(v); - fc_swap(tmp._data,_data); - return *this; - } - protected: - detail::data* _data; - }; - - template - struct vector_impl { - public: - typedef T* iterator; - typedef const T* const_iterator; - vector_impl():_data(nullptr){} - vector_impl( vector_impl&& c):_data(c._data){c._data =nullptr; } - vector_impl( const vector_impl& c):_data(nullptr) { - if( c.size() ) { - _data = detail::data::allocate( c.size() ); - auto i = begin(); - auto ci = c.begin(); - auto ce = c.end(); - while( ci != ce ) { - new (i) T(*ci); - ++i; - ++_data->size; - ++ci; - } - } - } - vector_impl(const_iterator b, const_iterator e ):_data(nullptr) { - resize(e-b); - for( auto i = begin(); i != end(); ++i ) { - *i = *b; - ++b; - } - } - - vector_impl(size_t s):_data(nullptr){ - resize(s); - } - ~vector_impl() { - clear(); - } - - - size_t size()const { return _data ? _data->size : 0; } - size_t capacity()const { return _data ? _data->capacity : 0; } - - T& back() { return (&_data->first)[-1+_data->size]; } - const T& back()const { return (&_data->first)[-1+_data->size]; } - T& front() { return (&_data->first)[0]; } - const T& front()const { return (&_data->first)[0]; } - const T* data()const { return (&_data->first); } - T* data() { return (&_data->first); } - - iterator begin() { return _data ? &front() : 0;} - const_iterator begin()const { return _data ? &front() : 0;} - const_iterator end()const { return _data ? (&back())+1: 0;} - iterator end(){ return _data ? (&back())+1: 0;} - - T& operator[]( size_t i ) { return (&_data->first)[i]; } - const T& operator[]( size_t i )const { return (&_data->first)[i]; } - - T& at( size_t i ) { return (&_data->first)[i]; } - const T& at( size_t i )const { return (&_data->first)[i]; } - - void pop_back() { erase( &back() ); } - - - void clear() { - if( this->_data != nullptr ) { - auto c = this->begin(); - auto e = this->end(); - while( c != e ) { - (*c).~T(); - ++c; - } - free(this->_data); - } - this->_data = nullptr; - } - - void reserve( size_t i ) { - if( nullptr != this->_data && i <= this->_data->capacity ) - return; - - auto _ndata = detail::data::allocate( i ); - auto nc = &_ndata->first; - auto c = this->begin(); - auto e = this->end(); - while( c != e ) { - new (nc) T(fc::move( *c )); - (*c).~T(); - ++_ndata->size; - ++c; - ++nc; - } - fc_swap( _ndata, this->_data ); - if( _ndata ) free(_ndata); - } - - void resize( size_t i ) { - this->reserve(i); - while( i < this->_data->size ) { - this->back().~T(); - --this->_data->size; - } - while( this->_data->size < i ) { - new (&this->back()+1) T(); - ++this->_data->size; - } - } - - template - void push_back( U&& v ) { - this->reserve( this->size()+1 ); - new (&back()+1) T(fc::forward(v)); - ++this->_data->size; - } - template - void emplace_back( U&& v ) { - this->reserve( this->size()+1 ); - new (&back()+1) T(fc::forward(v)); - ++this->_data->size; - } - - - - template - iterator insert( const_iterator loc, U&& t ) { - size_t pos = loc - this->begin(); - this->reserve( this->size()+1 ); - loc = this->begin() + pos; - if( this->size() != 0 ) { - new ((void*)this->end()) T( fc::move(this->back()) ); - auto cur = this->back(); - ++this->_data->size; - while( cur != loc ) { - *cur = fc::move( *(cur-1) ); - } - *cur = fc::forward(t); - } else { - new (this->end()) T( fc::forward(t) ); - ++this->_data->size; - } - return &this->at(pos); - } - - iterator insert( iterator pos, const_iterator first, const_iterator last ) { - //static_assert( false, "Not Implemented" ); - return 0; - } - - iterator erase( iterator pos ) { - if( pos == this->end() ) { return pos; } - auto next = pos + 1; - while( next != this->end() ) { - *pos = fc::move(*next); - ++pos; ++next; - } - pos->~T(); - this->_data->size--; - return pos; - } - - iterator erase( iterator first, iterator last ) { - iterator c = first; - iterator m = last; - iterator e = this->end(); - while( c != e ) { - if( m != e ) *c = fc::move( *m ); - else c->~T(); - ++c; - ++m; - } - this->_data->size -= last-first; - return last; - } - vector_impl& operator=( vector_impl&& v ) { - fc_swap(_data,v._data); - return *this; - } - vector_impl& operator=( const vector_impl& v ) { - vector_impl tmp(v); - fc_swap(tmp._data,_data); - return *this; - } - private: - detail::data* _data; - }; - } - - /** - * @brief provides a light-weight vector similar to std::vector except that - * it prevents needing to include which requires many more headers - * and increases compile times. - * - * This class should have the same API as std::vector and can be expanded as - * additional features of std::vector are required. - * - */ - template - class vector : public detail::vector_impl::type> { - public: - vector(){} - vector( size_t s ):detail::vector_impl::type>(s){} - vector( const vector& v ):detail::vector_impl::type>(v){} - vector( vector&& v ):detail::vector_impl::type>(fc::move(v)){} - - vector( const T* b, const T* e ):detail::vector_impl::type>(b,e){} - - vector& operator=( vector&& v ) { - *((base*)this) = fc::move(v); - return *this; - } - vector& operator=( const vector& v ) { - *((base*)this) = v; - return *this; - } - private: - typedef detail::vector_impl::type> base; - }; - -}; +#include diff --git a/src/crypto/base36.cpp b/src/crypto/base36.cpp index cbd1cc1..44ce7b4 100644 --- a/src/crypto/base36.cpp +++ b/src/crypto/base36.cpp @@ -9,7 +9,7 @@ namespace fc if( len == 0 ) return fc::string(); fc::bigint value( data, len ); auto base36 = "0123456789abcdefghijklmnopqrstuvwxyz"; - fc::vector out( static_cast(len * 1.6) + 1 ); + std::vector out( static_cast(len * 1.6) + 1 ); int pos = out.size() - 1; out[pos] = '\0'; fc::bigint _36(36); @@ -23,12 +23,12 @@ namespace fc return &out[pos]; //fc::string( &out[pos], out.size() - pos); } - fc::string to_base36( const fc::vector& vec ) + fc::string to_base36( const std::vector& vec ) { return to_base36( (const char*)vec.data(), vec.size() ); } - fc::vector from_base36( const fc::string& b36 ) + std::vector from_base36( const fc::string& b36 ) { fc::bigint value; diff --git a/src/crypto/base58.cpp b/src/crypto/base58.cpp index aeffe3f..f86a983 100644 --- a/src/crypto/base58.cpp +++ b/src/crypto/base58.cpp @@ -609,12 +609,12 @@ fc::string to_base58( const char* d, size_t s ) { return EncodeBase58( (const unsigned char*)d, (const unsigned char*)d+s ).c_str(); } -fc::vector from_base58( const fc::string& base58_str ) { +std::vector from_base58( const fc::string& base58_str ) { std::vector out; if( !DecodeBase58( base58_str.c_str(), out ) ) { FC_THROW_EXCEPTION( exception, "Unable to decode base58 string ${base58_str}", ("base58_str",base58_str) ); } - return fc::vector((const char*)out.data(), ((const char*)out.data())+out.size() ); + return std::vector((const char*)out.data(), ((const char*)out.data())+out.size() ); } /** * @return the number of bytes decoded diff --git a/src/crypto/bigint.cpp b/src/crypto/bigint.cpp index 431b36c..50355d1 100644 --- a/src/crypto/bigint.cpp +++ b/src/crypto/bigint.cpp @@ -8,7 +8,7 @@ namespace fc { bigint::bigint( const char* bige, uint32_t l ) { n = BN_bin2bn( (const unsigned char*)bige, l, NULL ); } - bigint::bigint( const fc::vector& bige ) { + bigint::bigint( const std::vector& bige ) { n = BN_bin2bn( (const unsigned char*)bige.data(), bige.size(), NULL ); } bigint::bigint( BIGNUM* in ) @@ -149,8 +149,8 @@ namespace fc { return BN_bn2dec(n); } - bigint::operator fc::vector()const { - fc::vector to(BN_num_bytes(n)); + bigint::operator std::vector()const { + std::vector to(BN_num_bytes(n)); BN_bn2bin(n,(unsigned char*)to.data()); return to; } @@ -158,7 +158,7 @@ namespace fc { /** encodes the big int as base64 string, or a number */ void to_variant( const bigint& bi, variant& v ) { - fc::vector ve = bi; + std::vector ve = bi; v = fc::variant(base64_encode((unsigned char*)ve.data(),ve.size())); } diff --git a/src/crypto/dh.cpp b/src/crypto/dh.cpp index 492cbcd..7b49398 100644 --- a/src/crypto/dh.cpp +++ b/src/crypto/dh.cpp @@ -84,7 +84,7 @@ namespace fc { DH_free(dh); return valid = true; } - bool diffie_hellman::compute_shared_key( const vector& pubk ) { + bool diffie_hellman::compute_shared_key( const std::vector& pubk ) { return compute_shared_key( &pubk.front(), pubk.size() ); } diff --git a/src/crypto/sha256.cpp b/src/crypto/sha256.cpp index 0e4526e..63b38cc 100644 --- a/src/crypto/sha256.cpp +++ b/src/crypto/sha256.cpp @@ -85,11 +85,11 @@ namespace fc { void to_variant( const sha256& bi, variant& v ) { - v = fc::vector( (const char*)&bi, ((const char*)&bi) + sizeof(bi) ); + v = std::vector( (const char*)&bi, ((const char*)&bi) + sizeof(bi) ); } void from_variant( const variant& v, sha256& bi ) { - fc::vector ve = v.as< vector >(); + std::vector ve = v.as< std::vector >(); if( ve.size() ) { memcpy(&bi, ve.data(), fc::min(ve.size(),sizeof(bi)) ); diff --git a/src/interprocess/process.cpp b/src/interprocess/process.cpp index 55a5e6c..5cb46d6 100644 --- a/src/interprocess/process.cpp +++ b/src/interprocess/process.cpp @@ -3,7 +3,6 @@ #include #include #include -#include #include #include #include @@ -74,11 +73,12 @@ process::process() process::~process(){} iprocess& process::exec( const fc::path& exe, - fc::vector args, + std::vector args, const fc::path& work_dir, exec_opts opt ) { my->pctx.work_dir = work_dir.string(); + my->pctx.suppress_console = (opt & suppress_console) != 0; if( opt&open_stdout) my->pctx.streams[boost::process::stdout_id] = bp::behavior::async_pipe(); @@ -96,12 +96,14 @@ iprocess& process::exec( const fc::path& exe, else my->pctx.streams[boost::process::stdin_id] = bp::behavior::close(); + /* std::vector a; a.reserve(size_t(args.size())); for( uint32_t i = 0; i < args.size(); ++i ) { a.push_back( fc::move(args[i]) ); } - my->child.reset( new bp::child( bp::create_child( exe.string(), fc::move(a), my->pctx ) ) ); + */ + my->child.reset( new bp::child( bp::create_child( exe.string(), fc::move(args), my->pctx ) ) ); if( opt & open_stdout ) { bp::handle outh = my->child->get_handle( bp::stdout_id ); diff --git a/src/io/iostream.cpp b/src/io/iostream.cpp index a0936d0..69ddc69 100644 --- a/src/io/iostream.cpp +++ b/src/io/iostream.cpp @@ -196,12 +196,13 @@ 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,10 +267,12 @@ namespace fc { return o; } +#ifdef USE_FC_STRING istream& operator>>( istream& o, fc::string& v ) { return o; } +#endif istream& operator>>( istream& o, char& v ) { diff --git a/src/log/logger.cpp b/src/log/logger.cpp index 830a279..f8d868f 100644 --- a/src/log/logger.cpp +++ b/src/log/logger.cpp @@ -20,7 +20,7 @@ namespace fc { bool _additivity; log_level _level; - fc::vector _appenders; + std::vector _appenders; }; diff --git a/src/network/http/http_connection.cpp b/src/network/http/http_connection.cpp index d52da20..b283a2d 100644 --- a/src/network/http/http_connection.cpp +++ b/src/network/http/http_connection.cpp @@ -37,7 +37,7 @@ class fc::http::connection::impl fc::http::reply parse_reply() { fc::http::reply rep; try { - fc::vector line(1024*8); + 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()))); @@ -131,7 +131,7 @@ fc::tcp_socket& connection::get_socket()const { http::request connection::read_request()const { http::request req; - fc::vector line(1024*8); + std::vector line(1024*8); int s = my->read_until( line.data(), line.data()+line.size(), ' ' ); // METHOD req.method = line.data(); s = my->read_until( line.data(), line.data()+line.size(), ' ' ); // PATH @@ -171,12 +171,12 @@ fc::string request::get_header( const fc::string& key )const { } return fc::string(); } -fc::vector
parse_urlencoded_params( const fc::string& f ) { +std::vector
parse_urlencoded_params( const fc::string& f ) { int num_args = 0; for( size_t i = 0; i < f.size(); ++i ) { if( f[i] == '=' ) ++num_args; } - fc::vector
h(num_args); + std::vector
h(num_args); int arg = 0; for( size_t i = 0; i < f.size(); ++i ) { while( f[i] != '=' && i < f.size() ) { diff --git a/src/network/resolve.cpp b/src/network/resolve.cpp index ec6b159..f5cbaf8 100644 --- a/src/network/resolve.cpp +++ b/src/network/resolve.cpp @@ -3,10 +3,10 @@ namespace fc { - fc::vector resolve( const fc::string& host, uint16_t port ) + std::vector resolve( const fc::string& host, uint16_t port ) { auto ep = fc::asio::tcp::resolve( host, std::to_string(uint64_t(port)) ); - fc::vector eps; + std::vector eps; eps.reserve(ep.size()); for( auto itr = ep.begin(); itr != ep.end(); ++itr ) eps.push_back( fc::ip::endpoint(itr->address().to_v4().to_ulong(), itr->port()) ); diff --git a/src/string.cpp b/src/string.cpp index b4945de..be55ca6 100644 --- a/src/string.cpp +++ b/src/string.cpp @@ -10,6 +10,7 @@ */ namespace fc { +#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) { } @@ -64,6 +65,7 @@ namespace fc { 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 ) diff --git a/src/thread/thread.cpp b/src/thread/thread.cpp index 701936a..b96a9ce 100644 --- a/src/thread/thread.cpp +++ b/src/thread/thread.cpp @@ -196,7 +196,7 @@ namespace fc { my->check_fiber_exceptions(); } - int thread::wait_any_until( fc::vector&& p, const time_point& timeout) { + int thread::wait_any_until( std::vector&& p, const time_point& timeout) { for( size_t i = 0; i < p.size(); ++i ) { if( p[i]->ready() ) return i; } @@ -282,10 +282,10 @@ namespace fc { return thread::current().exec(); } - int wait_any( fc::vector&& v, const microseconds& timeout_us ) { + int wait_any( std::vector&& v, const microseconds& timeout_us ) { return thread::current().wait_any_until( fc::move(v), time_point::now() + timeout_us ); } - int wait_any_until( fc::vector&& v, const time_point& tp ) { + int wait_any_until( std::vector&& v, const time_point& tp ) { return thread::current().wait_any_until( fc::move(v), tp ); } void thread::wait_until( promise_base::ptr&& p, const time_point& timeout ) { diff --git a/src/variant.cpp b/src/variant.cpp index 90e4cf7..8adab43 100644 --- a/src/variant.cpp +++ b/src/variant.cpp @@ -14,16 +14,16 @@ namespace fc void to_variant( const uint16_t& var, variant& vo ) { vo = uint64_t(var); } // TODO: warn on overflow? void from_variant( const variant& var, uint16_t& vo ){ vo = static_cast(var.as_uint64()); } -void to_variant( const vector& var, variant& vo ) +void to_variant( const std::vector& var, variant& vo ) { if( var.size() ) vo = variant(base64_encode((unsigned char*)var.data(),var.size())); else vo = ""; } -void from_variant( const variant& var, vector& vo ) +void from_variant( const variant& var, std::vector& vo ) { std::string b64 = base64_decode( var.as_string() ); - vo = fc::vector( b64.c_str(), b64.c_str() + b64.size() ); + vo = std::vector( b64.c_str(), b64.c_str() + b64.size() ); } /** * The TypeID is stored in the 'last byte' of the variant. diff --git a/src/variant_object.cpp b/src/variant_object.cpp index 6f5428e..f3cb488 100644 --- a/src/variant_object.cpp +++ b/src/variant_object.cpp @@ -96,12 +96,12 @@ namespace fc } variant_object::variant_object() - :_key_value(std::make_shared>() ) + :_key_value(std::make_shared>() ) { } variant_object::variant_object( string key, variant val ) - : _key_value(std::make_shared>()) + : _key_value(std::make_shared>()) { //_key_value->push_back(entry(fc::move(key), fc::move(val))); _key_value->emplace_back(entry(fc::move(key), fc::move(val))); @@ -116,12 +116,12 @@ namespace fc variant_object::variant_object( variant_object&& obj) : _key_value( fc::move(obj._key_value) ) { - obj._key_value = std::make_shared>(); + obj._key_value = std::make_shared>(); assert( _key_value != nullptr ); } variant_object::variant_object( const mutable_variant_object& obj ) - : _key_value(std::make_shared>(*obj._key_value)) + : _key_value(std::make_shared>(*obj._key_value)) { } @@ -153,7 +153,7 @@ namespace fc variant_object& variant_object::operator=( mutable_variant_object&& obj ) { _key_value = fc::move(obj._key_value); - obj._key_value.reset( new fc::vector() ); + obj._key_value.reset( new std::vector() ); return *this; } @@ -260,23 +260,23 @@ namespace fc } mutable_variant_object::mutable_variant_object() - :_key_value(new fc::vector) + :_key_value(new std::vector) { } mutable_variant_object::mutable_variant_object( string key, variant val ) - : _key_value(new fc::vector()) + : _key_value(new std::vector()) { _key_value->push_back(entry(fc::move(key), fc::move(val))); } mutable_variant_object::mutable_variant_object( const variant_object& obj ) - : _key_value( new fc::vector(*obj._key_value) ) + : _key_value( new std::vector(*obj._key_value) ) { } mutable_variant_object::mutable_variant_object( const mutable_variant_object& obj ) - : _key_value( new fc::vector(*obj._key_value) ) + : _key_value( new std::vector(*obj._key_value) ) { }