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

port to windows

Browse source
This commit is contained in:
Daniel Larimer 2012-12-03 14:51:31 -05:00
parent 0995ce7e31
commit e33e78ce51
31 changed files with 207 additions and 242 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
CMakeLists.txt
View file

@ -95,7 +95,7 @@ set( sources
setup_library( fc SOURCES ${sources} )
setup_executable( json_rpc_test SOURCES tests/json_rpc_test.cpp LIBRARIES fc ${pthread_library} ${rt_library} ${Boost_THREAD_LIBRARY} ${Boost_CONTEXT_LIBRARY} ${Boost_SYSTEM_LIBRARY} ${Boost_CHRONO_LIBRARY} ${Boost_FILESYSTEM_LIBRARY} ${rt_library} ${Boost_DATE_TIME_LIBRARY})
setup_executable( ssh_test SOURCES tests/ssh.cpp LIBRARIES fc ${pthread_library} ${rt_library} ${Boost_THREAD_LIBRARY} ${Boost_CONTEXT_LIBRARY} ${Boost_SYSTEM_LIBRARY} ${Boost_CHRONO_LIBRARY} ${Boost_FILESYSTEM_LIBRARY} ${rt_library} ssh2 ${OPENSSL_LIBRARY} ${OPENSSL_CRYPTO_LIBRARY} z ${Boost_DATE_TIME_LIBRARY})
setup_executable( ssh_test SOURCES tests/ssh.cpp LIBRARIES fc ${pthread_library} ${rt_library} ${Boost_THREAD_LIBRARY} ${Boost_CONTEXT_LIBRARY} ${Boost_SYSTEM_LIBRARY} ${Boost_CHRONO_LIBRARY} ${Boost_FILESYSTEM_LIBRARY} ${rt_library} ssh2 ${OPENSSL_LIBRARY} ${OPENSSL_CRYPTO_LIBRARY} ${ZLIB_LIBRARY} ${ALL_OPENSSL_LIBRARIES} ${Boost_DATE_TIME_LIBRARY})
#add_executable( test_vec tests/vector_test.cpp )
#target_link_libraries( test_vec fc ${Boost_SYSTEM_LIBRARY} ${Boost_CHRONO_LIBRARY} ${Boost_THREAD_LIBRARY} ${Boost_CONTEXT_LIBRARY} )

2
include/fc/filesystem.hpp
View file

@ -39,7 +39,7 @@ namespace fc {
fc::string string()const;
fc::string generic_string()const;
private:
fwd<boost::filesystem::path,8> _p;
fwd<boost::filesystem::path,32> _p;
};
class directory_iterator {

2
include/fc/future.hpp
View file

@ -79,7 +79,7 @@ namespace fc {
mutable spin_yield_lock _spin_yield;
thread* _blocked_thread;
time_point _timeout;
fc::exception_ptr _except;
fc::exception_ptr _exceptp;
bool _canceled;
const char* _desc;
detail::completion_handler* _compl;

4
include/fc/fwd.hpp
View file

@ -1,5 +1,4 @@
#ifndef FC_FWD_HPP_
#define FC_FWD_HPP_
#pragma once
#include <fc/aligned.hpp>
namespace fc {
@ -44,4 +43,3 @@ class fwd {
} // namespace fc
#endif

2
include/fc/interprocess/file_mapping.hpp
View file

@ -22,7 +22,7 @@ namespace fc {
~file_mapping();
private:
friend class mapped_region;
fc::fwd<boost::interprocess::file_mapping,16> my;
fc::fwd<boost::interprocess::file_mapping,0x24> my;
};
class mapped_region {
public:

4
include/fc/iostream.hpp
View file

@ -59,14 +59,14 @@ namespace fc {
template<typename T>
ostream& operator<<( ostream& o, const T& v ) {
auto str = fc::lexical_cast<fc::string>(v);
o.write( str.c_str(), str.size() );
o.write( str.c_str(), static_cast<size_t>(str.size()) );
return o;
}
ostream& operator<<( ostream& o, const char* v );
template<typename T>
ostream& operator<<( ostream& o, const fc::string& str ) {
o.write( str.c_str(), str.size() );
o.write( str.c_str(), static_cast<size_t>(str.size()) );
return o;
}
template<typename T>

2
include/fc/json_rpc_client.hpp
View file

@ -12,7 +12,7 @@ namespace fc { namespace json {
namespace detail {
struct rpc_member {
#if BOOST_NO_VARIADIC_TEMPLATES
#ifdef BOOST_NO_VARIADIC_TEMPLATES
#define RPC_MEMBER_FUNCTOR(z,n,IS_CONST) \
template<typename R, typename C, typename P BOOST_PP_ENUM_TRAILING_PARAMS( n, typename A)> \
static std::function<fc::future<R>( BOOST_PP_ENUM_PARAMS(n,A) ) > \

25
include/fc/lexical_cast.hpp
View file

@ -11,11 +11,11 @@ namespace fc {
inline double to_double( double d ) { return d; }
int64_t to_int64( const fc::string& s );
inline int64_t to_int64( double d ) { return d; }
inline int64_t to_int64( double d ) { return static_cast<int64_t>(d); }
inline int64_t to_int64( int64_t d ) { return d; }
uint64_t to_uint64( const fc::string& s );
inline uint64_t to_uint64( double d ) { return d; }
inline uint64_t to_uint64( double d ) { return static_cast<uint64_t>(d); }
inline uint64_t to_uint64( uint64_t d ) { return d; }
fc::string to_string( double d );
@ -47,32 +47,33 @@ namespace fc {
};
template<typename R>
struct lexical_cast<int64_t, R> { static uint64_t cast( const R& v ) { return to_int64( v ); } };
struct lexical_cast<int64_t, R> { static int64_t cast( const R& v ) { return static_cast<int64_t>(to_int64( v )); } };
template<typename R>
struct lexical_cast<int32_t, R> { static uint32_t cast( const R& v ) { return to_int64( v ); } };
struct lexical_cast<int32_t, R> { static int32_t cast( const R& v ) { return static_cast<int32_t>(to_int64( v )); } };
template<typename R>
struct lexical_cast<int16_t, R> { static uint16_t cast( const R& v ) { return to_int64( v ); } };
struct lexical_cast<int16_t, R> { static int16_t cast( const R& v ) { return static_cast<int16_t>(to_int64( v )); } };
template<typename R>
struct lexical_cast<int8_t, R> { static uint8_t cast( const R& v ) { return to_int64( v ); } };
struct lexical_cast<int8_t, R> { static int8_t cast( const R& v ) { return static_cast<int8_t>(to_int64( v )); } };
template<typename R>
struct lexical_cast<uint32_t, R> { static uint32_t cast( const R& v ) { return to_uint64( v ); } };
struct lexical_cast<uint32_t, R> { static uint32_t cast( const R& v ) { return static_cast<uint32_t>(to_uint64( v )); } };
template<typename R>
struct lexical_cast<uint16_t, R> { static uint16_t cast( const R& v ) { return to_uint64( v ); } };
struct lexical_cast<uint16_t, R> { static uint16_t cast( const R& v ) { return static_cast<uint16_t>(to_uint64( v )); } };
template<typename R>
struct lexical_cast<uint8_t, R> { static uint8_t cast( const R& v ) { return to_uint64( v ); } };
struct lexical_cast<uint8_t, R> { static uint8_t cast( const R& v ) { return static_cast<uint8_t>(to_uint64( v )); } };
template<typename R>
struct lexical_cast<bool, R> { static bool cast( const R& v ) { return v; } };
struct lexical_cast<bool, R> { static bool cast( const R& v ) { return v != 0; } };
template<>
struct lexical_cast<char, fc::string> { static bool cast( const fc::string& v ) { return v[0]; } };// TODO: check string len
struct lexical_cast<char, fc::string> { static char cast( const fc::string& v )
{ return v[0]; } };// TODO: check string len
template<>
struct lexical_cast<bool, fc::string> { static bool cast( const fc::string& v ) { return v == "true"; } };
@ -81,7 +82,7 @@ namespace fc {
struct lexical_cast<fc::string,bool> { static fc::string cast( const bool& v ) { return v ? "true" : "false";} };
template<typename R>
struct lexical_cast<float, R> { static float cast( const R& v ) { return to_double( v ); } };
struct lexical_cast<float, R> { static float cast( const R& v ) { return static_cast<float>(to_double( v )); } };
}

3
include/fc/ptr.hpp
View file

@ -2,6 +2,7 @@
//#include <fc/function.hpp>
#include <fc/future.hpp>
#include <functional>
#include <boost/config.hpp>
#include <boost/preprocessor/repeat.hpp>
#include <boost/preprocessor/repetition/enum_binary_params.hpp>
#include <boost/preprocessor/repetition/enum_params.hpp>
@ -12,7 +13,7 @@ namespace fc {
namespace detail {
struct identity_member {
#if BOOST_NO_VARIADIC_TEMPLATES
#ifdef BOOST_NO_VARIADIC_TEMPLATES
#define RPC_MEMBER_FUNCTOR(z,n,IS_CONST) \
template<typename R, typename C, typename P BOOST_PP_ENUM_TRAILING_PARAMS( n, typename A)> \
static std::function<R( BOOST_PP_ENUM_PARAMS(n,A) ) > \

3
include/fc/reflect.hpp
View file

@ -79,7 +79,8 @@ struct reflector{
#endif
//#include <boost/typeof/typeof.hpp>
#define FC_REFLECT_VISIT_MEMBER( r, visitor, elem ) \
visitor.TEMPLATE operator()<decltype(((type*)0)->elem), type, &type::elem>( BOOST_PP_STRINGIZE(elem) );
// visitor.TEMPLATE operator()<decltype(((type*)0)->elem), type, &type::elem>( BOOST_PP_STRINGIZE(elem) );
#define FC_REFLECT_BASE_MEMBER_COUNT( r, OP, elem ) \

10
include/fc/shared_impl.cpp
View file

@ -20,7 +20,7 @@ shared_impl<T>::shared_impl( shared_impl<T>&& u ):_impl(fc::move(u._impl)){}
template<typename T>
shared_impl<T>& shared_impl<T>::operator=( shared_impl<T>&& u ) {
fc::swap(_impl,u._impl);
fc_swap(_impl,u._impl);
return *this;
}
template<typename T>
@ -46,7 +46,7 @@ TYPE::TYPE( A1&& a1, A2&& a2 ) \
:my( new typename fc::shared_impl<TYPE>::impl( fc::forward<A1>(a1), fc::forward<A2>(a2) ) ){}\
template<typename A1,typename A2, typename A3> \
TYPE::TYPE( A1&& a1, A2&& a2, A3&& a3 ) \
:my( new typename fc::shared_impl<TYPE>::impl( fc::forward<A1>(a1), fc::forward<A2>(a2), fc::forward<A3>(a3) ) ){}\
:my( new fc::shared_impl<TYPE>::impl( fc::forward<A1>(a1), fc::forward<A2>(a2), fc::forward<A3>(a3) ) ){}\
TYPE::TYPE( shared_impl<TYPE>::impl* m ) \
:my(m){}\
TYPE::TYPE( TYPE* c )\
@ -56,7 +56,7 @@ TYPE::TYPE( TYPE&& c )\
TYPE::TYPE( const TYPE& c )\
:my(c.my){}\
TYPE::TYPE() \
:my( new typename fc::shared_impl<TYPE>::impl( ) ){}\
:my( new fc::shared_impl<TYPE>::impl( ) ){}\
TYPE::~TYPE(){}\
bool TYPE::operator !()const { return !my; }\
TYPE& TYPE::operator = ( const TYPE& c ) {\
@ -64,11 +64,11 @@ TYPE& TYPE::operator = ( const TYPE& c ) {\
return *this;\
}\
TYPE& TYPE::operator = ( TYPE&& c ) {\
fc::swap( my._impl, c.my._impl );\
fc_swap( my._impl, c.my._impl );\
return *this;\
}\
TYPE& TYPE::operator = ( TYPE* c ) {\
fc::swap( my._impl, c->my._impl );\
fc_swap( my._impl, c->my._impl );\
delete c;\
return *this;\
} \

4
include/fc/shared_impl.hpp
View file

@ -103,7 +103,7 @@ namespace fc {
*/
template<typename T>
struct shared_impl {
struct impl;
class impl;
impl& operator* ()const;
impl* operator-> ()const;
@ -119,7 +119,7 @@ namespace fc {
~shared_impl();
fc::shared_ptr<shared_impl::impl> _impl;
fc::shared_ptr<typename shared_impl<T>::impl> _impl;
};
}

4
include/fc/shared_ptr.hpp
View file

@ -56,11 +56,11 @@ namespace fc {
shared_ptr& operator=(const shared_ptr& p ) {
shared_ptr tmp(p);
fc::swap(tmp._ptr,_ptr);
fc_swap(tmp._ptr,_ptr);
return *this;
}
shared_ptr& operator=(shared_ptr&& p ) {
fc::swap(_ptr,p._ptr);
fc_swap(_ptr,p._ptr);
return *this;
}
T& operator* ()const { return *_ptr; }

11
include/fc/string.hpp
View file

@ -1,6 +1,6 @@
#ifndef _FC_STRING_HPP_
#define _FC_STRING_HPP_
#pragma once
#include <fc/utility.hpp>
#include <fc/fwd.hpp>
/**
@ -13,10 +13,10 @@ namespace std {
struct char_traits;
template<class T>
struct allocator;
class allocator;
template<class Char, class Traits, class Allocator>
struct basic_string;
class basic_string;
typedef basic_string<char, char_traits<char>, allocator<char> > string;
}
@ -85,9 +85,8 @@ namespace fc {
fc::string substr( int32_t start, int32_t len = 0x7fffffff );
private:
void* my;
fc::fwd<std::string,32> my;
};
} // namespace FC
#endif // _FC_STRING_HPP_

2
include/fc/tcp_socket.hpp
View file

@ -32,7 +32,7 @@ namespace fc {
private:
friend class tcp_server;
class impl;
fc::fwd<impl,32> my;
fc::fwd<impl,0x44> my;
};
class tcp_server {

22
include/fc/tuple.hpp
View file

@ -60,8 +60,8 @@ namespace fc {
template<typename V>
void visit( V&& v)const{};
};
template<typename Functor, typename Tuple>
auto call_fused( Functor f, Tuple&& t ) -> decltype( f( ) ) {
template<typename Functor>
auto call_fused( Functor f, const tuple<>& t ) -> decltype( f( ) ) {
return f();
}
@ -72,13 +72,13 @@ namespace fc {
typedef fc::false_type type;
};
#define RREF_PARAMS(z,n,data) BOOST_PP_CAT(AA,n)&& BOOST_PP_CAT(a,n)
#define ILIST_PARAMS(z,n,data) BOOST_PP_CAT(a,n)( fc::forward<BOOST_PP_CAT(AA,n)>( BOOST_PP_CAT(a,n) ) )
#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(AA,n)>( 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<BOOST_PP_CAT(AA,n)>::type
#define FORWARD_PARAMS(z,n,data) fc::forward<BOOST_PP_CAT(AA,n)>(BOOST_PP_CAT(a,n))
#define FORWARD_PARAMS(z,n,data) fc::forward<BOOST_PP_CAT(AA,n)>(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<BOOST_PP_ENUM_PARAMS( n, typename A)> \
@ -87,6 +87,7 @@ namespace fc {
template<BOOST_PP_ENUM_PARAMS( n, typename AA)> \
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( tuple&& t )BOOST_PP_IF(n,:,BOOST_PP_EMPTY())BOOST_PP_ENUM( n, ILIST_PARAMS_COPY,unused){} \
tuple(){}\
template<typename V>\
@ -99,8 +100,13 @@ namespace fc {
tuple<BOOST_PP_ENUM_PARAMS(n,AA)> make_tuple( BOOST_PP_ENUM( n, RREF_PARAMS, unused) ) { \
return tuple<BOOST_PP_ENUM_PARAMS(n,AA)>( BOOST_PP_ENUM( n, FORWARD_PARAMS,unused ) ); \
} \
template<typename Functor, typename Tuple> \
auto call_fused( Functor f, Tuple&& t ) \
template<typename Functor, BOOST_PP_ENUM_PARAMS(n,typename AA)> \
auto call_fused( Functor f, tuple<BOOST_PP_ENUM_PARAMS(n,AA)>& t ) \
-> decltype( f( BOOST_PP_ENUM( n, LIST_MEMBERS_ON, t) ) ) { \
return f( BOOST_PP_ENUM( n, LIST_MEMBERS_ON, t) ); \
} \
template<typename Functor, BOOST_PP_ENUM_PARAMS(n,typename AA)> \
auto call_fused( Functor f, const tuple<BOOST_PP_ENUM_PARAMS(n,AA)>& t ) \
-> decltype( f( BOOST_PP_ENUM( n, LIST_MEMBERS_ON, t) ) ) { \
return f( BOOST_PP_ENUM( n, LIST_MEMBERS_ON, t) ); \
} \
@ -113,7 +119,7 @@ namespace fc {
typedef fc::tuple<BOOST_PP_ENUM( n, DEDUCE_MEMBERS,unused)> type; \
};
BOOST_PP_REPEAT_FROM_TO( 1, 8, TUPLE, unused )
BOOST_PP_REPEAT_FROM_TO( 1, 4, TUPLE, unused )
#undef FORWARD_PARAMS

5
include/fc/utility.hpp
View file

@ -41,11 +41,12 @@ namespace fc {
template<typename T>
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<typename T>
void swap( T& a, T& b ) {
void fc_swap( T& a, T& b ) {
T tmp = fc::move(a);
a = fc::move(b);
b = fc::move(tmp);
}
}
#endif // _FC_UTILITY_HPP_

2
include/fc/value.hpp
View file

@ -96,7 +96,7 @@ namespace fc {
template<typename T>
value& operator=( T&& v ) {
value tmp(fc::forward<T>(v) );
fc::swap(*this,tmp);
fc_swap(*this,tmp);
return *this;
}

28
include/fc/value_cast.hpp
View file

@ -28,7 +28,7 @@ namespace fc {
virtual void operator()( const uint64_t& v ){ m_out = fc::numeric_cast<T>(v); }
virtual void operator()( const float& v ){ m_out = fc::numeric_cast<T>(v); }
virtual void operator()( const double& v ){ m_out = fc::numeric_cast<T>(v); }
virtual void operator()( const bool& v ){ m_out = fc::numeric_cast<T>(v); }
virtual void operator()( const bool& v ){ m_out = v; }
virtual void operator()( const fc::string& v ) { m_out = fc::lexical_cast<T>(v); }
virtual void operator()( const value::object& ) { FC_THROW_MSG("bad cast"); }
virtual void operator()( const value::array& ) { FC_THROW_MSG("bad cast"); }
@ -36,6 +36,28 @@ namespace fc {
private:
T& m_out;
};
template<>
struct cast_visitor<bool> : value::const_visitor {
cast_visitor( bool& out )
:m_out(out){}
virtual void operator()( const int8_t& v ){ m_out = v != 0; }
virtual void operator()( const int16_t& v ){ m_out = v != 0; }
virtual void operator()( const int32_t& v ){ m_out = v != 0; }
virtual void operator()( const int64_t& v ){ m_out = v != 0; }
virtual void operator()( const uint8_t& v ){ m_out = v != 0; }
virtual void operator()( const uint16_t& v ){ m_out = v != 0; }
virtual void operator()( const uint32_t& v ){ m_out = v != 0; }
virtual void operator()( const uint64_t& v ){ m_out = v != 0; }
virtual void operator()( const float& v ){ m_out = v != 0; }
virtual void operator()( const double& v ){ m_out = v != 0; }
virtual void operator()( const bool& v ){ m_out = v; }
virtual void operator()( const fc::string& v ) { m_out = !(v != "true"); }
virtual void operator()( const value::object& ) { FC_THROW_MSG("bad cast"); }
virtual void operator()( const value::array& ) { FC_THROW_MSG("bad cast"); }
virtual void operator()( ) { FC_THROW_MSG("bad cast"); }
private:
bool& m_out;
};
template<>
struct cast_visitor<fc::string> : value::const_visitor {
@ -51,7 +73,7 @@ namespace fc {
virtual void operator()( const uint64_t& v ){ m_out = fc::lexical_cast<fc::string>(v); }
virtual void operator()( const float& v ){ m_out = fc::lexical_cast<fc::string>(v); }
virtual void operator()( const double& v ){ m_out = fc::lexical_cast<fc::string>(v); }
virtual void operator()( const bool& v ){ m_out = fc::lexical_cast<fc::string>(v); }
virtual void operator()( const bool& v ){ m_out = v != 0 ? "true" : "false"; }
virtual void operator()( const fc::string& v ){ m_out = v; }
virtual void operator()( const value::object& ) { FC_THROW_MSG("bad cast"); }
virtual void operator()( const value::array& ) { FC_THROW_MSG("bad cast"); }
@ -165,7 +187,7 @@ namespace fc {
template<>
struct cast_visitor<void> : value::value::const_visitor {
struct cast_visitor<void> : value::const_visitor {
virtual void operator()( const int8_t& v ) { FC_THROW_MSG("bad cast");}
virtual void operator()( const int16_t& v ) { FC_THROW_MSG("bad cast");}
virtual void operator()( const int32_t& v ) { FC_THROW_MSG("bad cast");}

36
include/fc/vector.hpp
View file

@ -1,5 +1,4 @@
#ifndef _FC_VECTOR_HPP_
#define _FC_VECTOR_HPP_
#pragma once
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
@ -7,15 +6,6 @@
#include <fc/log.hpp>
#if 0
#include <vector>
namespace fc {
template<typename T>
using vector = std::vector<T>;
}
#else
namespace fc {
namespace detail {
template<typename T>
@ -27,8 +17,8 @@ namespace fc {
static data* allocate( uint64_t cap ) {
data* d = nullptr;
if( cap ){
d = (data*)malloc(sizeof(data) + sizeof(T)*(cap-1));
d->capacity = cap;
d = (data*)malloc(sizeof(data) + sizeof(T)*(static_cast<size_t>(cap)-1));
d->capacity = static_cast<size_t>(cap);
} else {
d = (data*)malloc(sizeof(data));
d->capacity = 1;
@ -38,8 +28,8 @@ namespace fc {
}
static data* reallocate( data* d, uint64_t cap ) {
if( cap ){
d = (data*)realloc(d,sizeof(data) + sizeof(T)*(cap-1));
d->capacity = cap;
d = (data*)realloc(d,sizeof(data) + sizeof(T)*(static_cast<size_t>(cap)-1));
d->capacity = static_cast<size_t>(cap);
} else {
d = (data*)realloc(d,sizeof(data));
d->capacity = 1;
@ -64,13 +54,13 @@ namespace fc {
if( c.size() ) {
_data = detail::data<T>::allocate( c.size() );
_data->size = c.size();
memcpy(begin(),c.begin(),c.size() );
memcpy(begin(),c.begin(), static_cast<size_t>(c.size()) );
}
//slog( "copy: this.size %d", size() );
}
vector_impl(const_iterator b, const_iterator e ):_data(nullptr) {
resize(e-b);
if( size() ) memcpy( data(), b, size() );
if( size() ) memcpy( data(), b, static_cast<size_t>(size()) );
}
vector_impl(uint64_t s):_data(nullptr){
resize(s);
@ -170,12 +160,12 @@ namespace fc {
}
vector_impl& operator=( vector_impl&& v ) {
fc::swap(_data,v._data);
fc_swap(_data,v._data);
return *this;
}
vector_impl& operator=( const vector_impl& v ) {
vector_impl tmp(v);
fc::swap(tmp._data,_data);
fc_swap(tmp._data,_data);
return *this;
}
protected:
@ -270,7 +260,7 @@ namespace fc {
++c;
++nc;
}
fc::swap( _ndata, this->_data );
fc_swap( _ndata, this->_data );
if( _ndata ) free(_ndata);
}
@ -344,12 +334,12 @@ namespace fc {
return last;
}
vector_impl& operator=( vector_impl&& v ) {
fc::swap(_data,v._data);
fc_swap(_data,v._data);
return *this;
}
vector_impl& operator=( const vector_impl& v ) {
vector_impl tmp(v);
fc::swap(tmp._data,_data);
fc_swap(tmp._data,_data);
return *this;
}
private:
@ -380,6 +370,4 @@ namespace fc {
};
};
#endif
#endif // _FC_VECTOR_HPP_

2
src/bigint.cpp
View file

@ -69,7 +69,7 @@ namespace fc {
bigint& bigint::operator = ( bigint&& a ) {
fc::swap( a.n, n );
fc_swap( a.n, n );
return *this;
}
bigint& bigint::operator = ( const bigint& a ) {

10
src/future.cpp
View file

@ -31,12 +31,12 @@ namespace fc {
}
bool promise_base::error()const {
{ synchronized(_spin_yield)
return _except;
return _exceptp;
}
}
void promise_base::set_exception( const fc::exception_ptr& e ){
_except = e;
_exceptp = e;
_set_value(nullptr);
}
@ -47,14 +47,14 @@ namespace fc {
void promise_base::_wait_until( const time_point& timeout_us ){
{ synchronized(_spin_yield)
if( _ready ) {
if( _except ) fc::rethrow_exception( _except );
if( _exceptp ) fc::rethrow_exception( _exceptp );
return;
}
_enqueue_thread();
}
thread::current().wait_until( ptr(this,true), timeout_us );
if( _ready ) {
if( _except ) fc::rethrow_exception( _except );
if( _exceptp ) fc::rethrow_exception( _exceptp );
return;
}
FC_THROW( future_wait_timeout() );
@ -80,7 +80,7 @@ namespace fc {
}
_notify();
if( nullptr != _compl ) {
_compl->on_complete(s,_except);
_compl->on_complete(s,_exceptp);
}
}
void promise_base::_on_complete( detail::completion_handler* c ) {

3
src/iostream.cpp
View file

@ -4,6 +4,7 @@
#include <iostream>
#include <string.h>
#include <fc/log.hpp>
#include <string>
namespace fc {
ostream& operator<<( ostream& o, const char* v ) {
@ -86,7 +87,7 @@ namespace fc {
void cerr_t::close() {};
void cerr_t::flush() { std::cerr.flush(); }
ostream& cerr_t::write( const fc::string& s ) { std::cerr<< *reinterpret_cast<const std::string*>(&s); return *this; }
ostream& cerr_t::write( const fc::string& s ) { std::cerr<< static_cast<std::string>(s); return *this; }
size_t cin_t::readsome( char* buf, size_t len ) {
cin_buffer& b = get_cin_buffer();

101
src/json.cpp
View file

@ -6,6 +6,7 @@
#include <fc/interprocess/file_mapping.hpp>
#include <map>
namespace fc { namespace json {
/**
* Placeholder for unparsed json data.
@ -39,6 +40,11 @@ namespace fc { namespace json {
fc::vector<char> json_data;
};
} }
typedef std::map<fc::string,fc::json::string> jmap;
namespace errors {
enum error_type {
unknown_error = 0x0001, // Other errors not specified below
@ -107,9 +113,9 @@ namespace fc { namespace json {
}
enum error_defaults {
default_report = json::errors::all,
default_recover = json::errors::all,
default_throw = json::errors::none,
default_report = errors::all,
default_recover = errors::all,
default_throw = errors::none,
default_ignore = ~(default_report|default_recover|default_throw)
};
@ -181,7 +187,7 @@ namespace fc { namespace json {
namespace fc { namespace json {
fc::string escape_string( const fc::string& s ) {
// calculate escape string size.
uint32_t ecount = 0;
@ -246,9 +252,9 @@ namespace fc { namespace json {
case '"' : out += '"'; break;
case 'x' : {
++i; if( i == out.end() ) return out;
char c = from_hex(*i);
char c = fc::from_hex(*i);
++i; if( i == out.end() ) { out += c; return out; }
c = c<<4 | from_hex(*i);
c = c<<4 | fc::from_hex(*i);
out += c;
break;
}
@ -290,9 +296,9 @@ namespace fc { namespace json {
case '"' : *out = '"'; ++out; break;
case 'x' : {
++i; if( *i == '\0' ){ *out = '\0'; return s; }
char c = from_hex(*i);
char c = fc::from_hex(*i);
++i; if( *i == '\0' ){ *out = c; ++out; *out = '\0'; return s; }
c = c<<4 | from_hex(*i);
c = c<<4 | fc::from_hex(*i);
*out = c;
++out;
break;
@ -308,6 +314,7 @@ namespace fc { namespace json {
*out = '\0';
return s;
}
} }// fc::json
/**
* Ignores leading white space.
@ -435,12 +442,12 @@ struct temp_set {
* A,B,C
* Warn on extra ',' or missing ','
*/
void read_values( value::array& a, char* in, char* end, fc::json::error_collector& ec ) {
void read_values( fc::value::array& a, char* in, char* end, error_collector& ec ) {
char* ve = 0;
char* v = fc::json::read_value( in, end, ve );
char* v = read_value( in, end, ve );
while( *v == ',' ) {
wlog( "unexpected ','");
v = fc::json::read_value( ve, end, ve );
v = read_value( ve, end, ve );
}
if( v == ve ) return; // no values
@ -451,7 +458,7 @@ void read_values( value::array& a, char* in, char* end, fc::json::error_collect
do { // expect comma + value | ''
// expect comma or ''
c = fc::json::read_value( ve, end, ce );
c = read_value( ve, end, ce );
// '' means we are done, no errors
if( c == ce ) return;
@ -465,12 +472,12 @@ void read_values( value::array& a, char* in, char* end, fc::json::error_collect
}
// expect value
v = fc::json::read_value( ce, end, ve );
v = read_value( ce, end, ve );
while ( *v == ',' ) { // but got comma
// expect value
wlog( "extra comma at c->ce" );
c = v; ce = ve;
v = fc::json::read_value( ve, end, ve );
v = read_value( ve, end, ve );
}
if( v == ve ) {
wlog( "trailing comma at c->ce" );
@ -485,22 +492,22 @@ void read_values( value::array& a, char* in, char* end, fc::json::error_collect
/**
* Reads one level deep, does not recruse into sub objects.
*/
char* read_key_val( std::map<fc::string,json::string>& obj, bool sc, char* in, char* end, fc::json::error_collector& ec ) {
char* read_key_val( std::map<fc::string,fc::json::string>& obj, bool sc, char* in, char* end, error_collector& ec ) {
char* name_end = 0;
char* name = in;
do {
// read first char
name = fc::json::read_value( name, end, name_end );
name = read_value( name, end, name_end );
if( sc ) { // if we expect a ,
if( *name != ',' ) { // but didn't get one
wlog( "expected ',' but got %1%", name ); // warn and accept name
} else { // we got the exepcted , read the expected name
name = fc::json::read_value( name_end, end, name_end );
name = read_value( name_end, end, name_end );
}
} else { // don't start with ','
while( *name == ',' ) { // while we don't have a name, keep looking
wlog( "unexpected ',' " );
name = fc::json::read_value( name_end, end, name_end );
name = read_value( name_end, end, name_end );
}
}
} while( *name == ',' );
@ -517,11 +524,11 @@ char* read_key_val( std::map<fc::string,json::string>& obj, bool sc, char* in, c
wlog( "unquoted name '%1%'", name );
} else {
temp_set ntemp(name_end,'\0');
name = inplace_unescape_string(name);
name = fc::json::inplace_unescape_string(name);
}
char* col_end = 0;
char* col = fc::json::read_value( name_end, end, col_end );
char* col = read_value( name_end, end, col_end );
char* val_end = 0;
char* val = 0;
@ -555,7 +562,7 @@ char* read_key_val( std::map<fc::string,json::string>& obj, bool sc, char* in, c
elog( "early end after reading name '%1%' and col '%2%'", name, col );
return name_end;
}
val = fc::json::read_value( col_end, end, val_end );
val = read_value( col_end, end, val_end );
if( val == end ) {
wlog( "no value specified" );
}
@ -576,12 +583,12 @@ char* read_key_val( std::map<fc::string,json::string>& obj, bool sc, char* in, c
* Reads an optional ',' followed by key : value, returning the next input position
* @param sc - start with ','
*/
char* read_key_val( value::object& obj, bool sc, char* in, char* end, fc::json::error_collector& ec ) {
char* read_key_val( fc::value::object& obj, bool sc, char* in, char* end, error_collector& ec ) {
char* name_end = 0;
char* name = in;
do {
// read first char
name = fc::json::read_value( name, end, name_end );
name = read_value( name, end, name_end );
if( name == name_end )
return name;
if( sc ) { // if we expect a ,
@ -589,12 +596,12 @@ char* read_key_val( value::object& obj, bool sc, char* in, char* end, fc::json::
if( *name != '}' )
wlog( "expected ',' or '}' but got '%s'", name ); // warn and accept name
} else { // we got the exepcted , read the expected name
name = fc::json::read_value( name_end, end, name_end );
name = read_value( name_end, end, name_end );
}
} else { // don't start with ','
while( *name == ',' ) { // while we don't have a name, keep looking
wlog( "unexpected ',' " );
name = fc::json::read_value( name_end, end, name_end );
name = read_value( name_end, end, name_end );
}
}
} while( *name == ',' );
@ -611,11 +618,11 @@ char* read_key_val( value::object& obj, bool sc, char* in, char* end, fc::json::
wlog( "unquoted name '%1%'", name );
} else {
temp_set ntemp(name_end,'\0');
name = inplace_unescape_string(name);
name = fc::json::inplace_unescape_string(name);
}
char* col_end = 0;
char* col = fc::json::read_value( name_end, end, col_end );
char* col = read_value( name_end, end, col_end );
char* val_end = 0;
char* val = 0;
@ -649,7 +656,7 @@ char* read_key_val( value::object& obj, bool sc, char* in, char* end, fc::json::
elog( "early end after reading name '%1%' and col '%2%'", name, col );
return name_end;
}
val = fc::json::read_value( col_end, end, val_end );
val = read_value( col_end, end, val_end );
if( val == end ) {
wlog( "no value specified" );
}
@ -657,13 +664,13 @@ char* read_key_val( value::object& obj, bool sc, char* in, char* end, fc::json::
temp_set ntemp(name_end,'\0');
temp_set vtemp(val_end,'\0');
//slog( "name: '%1%'", fc::string(name,name_end) );
obj.fields.push_back( value::key_val( name, to_value( val, val_end, ec ) ) );
obj.fields.push_back( fc::value::key_val( name, to_value( val, val_end, ec ) ) );
return val_end;
}
// first_key =:: '' | "name" : VALUE *list_key
// list_key '' | ',' "name" : VALUE
void read_key_vals( value::object& obj, char* in, char* end, fc::json::error_collector& ec ) {
void read_key_vals( fc::value::object& obj, char* in, char* end, error_collector& ec ) {
bool ex_c = false;
char* kv_end = in;
do {
@ -674,8 +681,8 @@ void read_key_vals( value::object& obj, char* in, char* end, fc::json::error_col
}
// first_key =:: '' | "name" : VALUE *list_key
// list_key '' | ',' "name" : VALUE
std::map<fc::string,json::string> read_key_vals( char* in, char* end, fc::json::error_collector& ec ) {
std::map<fc::string,json::string> m;
std::map<fc::string,fc::json::string> read_key_vals( char* in, char* end, error_collector& ec ) {
std::map<fc::string,fc::json::string> m;
bool ex_c = false;
char* kv_end = in;
do {
@ -692,7 +699,7 @@ std::map<fc::string,json::string> read_key_vals( char* in, char* end, fc::json::
* @brief adaptor for to_value( char*, char*, error_collector& )
*/
fc::value to_value( fc::vector<char>&& v, error_collector& ec ) {
if( v.size() == 0 ) return value();
if( v.size() == 0 ) return fc::value();
return to_value( &v.front(), &v.front() + v.size(), ec );
}
@ -703,21 +710,21 @@ fc::value to_value( fc::vector<char>&& v, error_collector& ec ) {
* any errors that occur while parsing the string.
*/
fc::value to_value( char* start, char* end, error_collector& ec ) {
if( start == end ) return value();
if( start == end ) return fc::value();
char* ve = 0;
char* s = read_value( start, end, ve );
//slog( "'%1%'", fc::string(start,ve) );
switch( s[0] ) {
case '[': {
value::array a;
fc::value::array a;
read_values( a, s+1, ve -1, ec );
return a;
}
case '{': {
value::object o;
fc::value::object o;
read_key_vals( o, s+1, ve -1, ec );
value v = fc::move(o);
fc::value v = fc::move(o);
return v;
}
case '0':
@ -753,11 +760,11 @@ fc::value to_value( char* start, char* end, error_collector& ec ) {
}
case '\"': {
temp_set move_end(ve,'\0');
return inplace_unescape_string( s );
return fc::json::inplace_unescape_string( s );
}
case 'n': {
temp_set move_end(ve,'\0');
if( strcmp(s,"null" ) == 0) return value();
if( strcmp(s,"null" ) == 0) return fc::value();
}
case 't': {
temp_set move_end(ve,'\0');
@ -770,9 +777,10 @@ fc::value to_value( char* start, char* end, error_collector& ec ) {
default:
wlog( "return unable to parse... return as string '%s'", fc::string(s,ve).c_str() );
return value( fc::string( s, ve) );
return fc::value( fc::string( s, ve) );
}
}
namespace fc { namespace json {
fc::string pretty_print( fc::vector<char>&& v, uint8_t indent ) {
int level = 0;
@ -871,8 +879,8 @@ fc::string pretty_print( fc::vector<char>&& v, uint8_t indent ) {
virtual void operator()( const float& v ){ os << v; }
virtual void operator()( const double& v ){ os << v; }
virtual void operator()( const bool& v ){ os << (v ? "true" : "false"); }
virtual void operator()( const fc::string& v ){ os << '"' << escape_string(v) <<'"'; }
virtual void operator()( const value::object& o ){
virtual void operator()( const fc::string& v ){ os << '"' << fc::json::escape_string(v) <<'"'; }
virtual void operator()( const fc::value::object& o ){
os << '{';
for( uint32_t i = 0; i < o.fields.size(); ++i ) {
if( i ) os <<',';
@ -918,7 +926,7 @@ fc::string pretty_print( fc::vector<char>&& v, uint8_t indent ) {
// memory map the file
file_mapping fmap( local_path.string().c_str(), read_only );
size_t fsize = file_size(local_path);
size_t fsize = static_cast<size_t>(file_size(local_path));
mapped_region mr( fmap, fc::read_only, 0, fsize );
@ -929,8 +937,8 @@ fc::string pretty_print( fc::vector<char>&& v, uint8_t indent ) {
// TODO: implement a const version of to_value
fc::vector<char> tmp(pos,end);
json::error_collector ec;
return fc::json::to_value(tmp.data(), tmp.data()+fsize,ec);
error_collector ec;
return to_value(tmp.data(), tmp.data()+fsize,ec);
}
value from_string( const fc::string& s ) {
@ -945,5 +953,4 @@ fc::string pretty_print( fc::vector<char>&& v, uint8_t indent ) {
return from_string( fc::vector<char>(s,e) );
}
}} // fc::json
} }

4
src/json_rpc_connection.cpp
View file

@ -122,7 +122,7 @@ namespace fc { namespace json {
rpc_connection::rpc_connection( const rpc_connection& c )
:my(c.my){ }
rpc_connection::rpc_connection( rpc_connection&& c ) {
fc::swap(my,c.my);
fc_swap(my,c.my);
}
rpc_connection::~rpc_connection() {
}
@ -132,7 +132,7 @@ namespace fc { namespace json {
return *this;
}
rpc_connection& rpc_connection::operator=(rpc_connection&& m) {
fc::swap(m.my,my);
fc_swap(m.my,my);
return *this;
}

6
src/log.cpp
View file

@ -4,7 +4,9 @@
#include <stdio.h>
#include <string.h>
#include <stdarg.h>
#ifndef WIN32
#include <unistd.h>
#endif
#include <iostream>
@ -32,8 +34,10 @@ namespace fc {
void log( const char* color, const char* file_name, size_t line_num,
const char* method_name, const char* format, ... ) {
fc::unique_lock<boost::mutex> lock(log_mutex());
#ifndef WIN32
if(isatty(fileno(stderr)))
std::cerr<<"\r"<<color;
#endif
fprintf( stderr, "%-15s %-15s %-5zd %-15s ", thread_name(), short_name(file_name), line_num, method_name );
//std::cerr<<thread_ptr()<< thread_name()<< short_name(file_name)<< line_num<< method_name ;
@ -41,8 +45,10 @@ namespace fc {
va_start(args,format);
vfprintf( stderr, format, args );
va_end(args);
#ifndef WIN32
if (isatty(fileno(stderr)))
fprintf( stderr, "%s", CONSOLE_DEFAULT );
#endif
fprintf( stderr, "\n" );
fflush( stderr );
}

1
src/process.cpp
View file

@ -54,6 +54,7 @@ namespace fc {
} // namespace fc
FC_START_SHARED_IMPL( fc::process )
public:
impl()
:stat( fc::asio::default_io_service() ),
std_out(process_source(outp)),

135
src/string.cpp
View file

@ -1,13 +1,8 @@
#include <fc/string.hpp>
#include <fc/utility.hpp>
#include <fc/fwd_impl.hpp>
#include <string>
namespace detail {
void destroy( void* t ) {
using namespace std;
reinterpret_cast<std::string*>(t)->~string();
}
}
/**
* Implemented with std::string for now.
@ -15,112 +10,48 @@ namespace detail {
namespace fc {
string::string(const char* s, int l) {
static_assert( sizeof(*this) >= sizeof(std::string), "failed to reserve enough space" );
new (this) std::string(s,l);
}
string::string() {
static_assert( sizeof(*this) >= sizeof(std::string), "failed to reserve enough space" );
new (this) std::string();
}
string::string( const string& c ) {
static_assert( sizeof(my) >= sizeof(std::string), "failed to reserve enough space" );
new (this) std::string(reinterpret_cast<const std::string&>(c));
}
string::string( string&& m ) {
static_assert( sizeof(my) >= sizeof(std::string), "failed to reserve enough space" );
new (this) std::string(reinterpret_cast<std::string&&>(m));
}
string::string( const char* c ){
static_assert( sizeof(my) >= sizeof(std::string), "failed to reserve enough space" );
new (this) std::string(c);
}
string::string( const_iterator b, const_iterator e ) {
static_assert( sizeof(my) >= sizeof(std::string), "failed to reserve enough space" );
new (this) std::string(b,e);
}
string::string( const std::string& s ) {
static_assert( sizeof(my) >= sizeof(std::string), "failed to reserve enough space" );
new (this) std::string(s);
}
string::string( std::string&& s ) {
static_assert( sizeof(my) >= sizeof(std::string), "failed to reserve enough space" );
new (this) std::string(fc::move(s));
}
string::operator std::string&() {
return *reinterpret_cast<std::string*>(this);
}
string::operator const std::string&()const {
return *reinterpret_cast<const std::string*>(this);
}
string::~string() {
::detail::destroy( this );
}
string::string(const char* s, int l) :my(s,l){ }
string::string(){}
string::string( const 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; }
string::iterator string::begin() { return &(*this)[0]; }
string::iterator string::end() { return &(*this)[size()]; }
string::const_iterator string::begin()const { return reinterpret_cast<const std::string*>(this)->c_str(); }
string::const_iterator string::end()const { return reinterpret_cast<const std::string*>(this)->c_str() + reinterpret_cast<const std::string*>(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[](uint64_t idx) { return reinterpret_cast<std::string*>(this)->at(idx); }
const char& string::operator[](uint64_t idx)const { return reinterpret_cast<const std::string*>(this)->at(idx); }
char& string::operator[](uint64_t idx) { return (*my)[idx]; }
const char& string::operator[](uint64_t idx)const { return (*my)[idx]; }
void string::reserve(uint64_t r) { reinterpret_cast<std::string*>(this)->reserve(r); }
uint64_t string::size()const { return reinterpret_cast<const std::string*>(this)->size(); }
uint64_t string::find(char c, uint64_t p)const { return reinterpret_cast<const std::string*>(this)->find(c,p); }
void string::clear() { return reinterpret_cast<std::string*>(this)->clear(); }
void string::resize( uint64_t s ) { reinterpret_cast<std::string*>(this)->resize(s); }
void string::reserve(uint64_t r) { my->reserve(r); }
uint64_t string::size()const { return my->size(); }
uint64_t string::find(char c, uint64_t p)const { return my->find(c,p); }
void string::clear() { my->clear(); }
void string::resize( uint64_t s ) { my->resize(s); }
fc::string string::substr( int32_t start, int32_t len ) { return my->substr(start,len); }
const char* string::c_str()const { return my->c_str(); }
fc::string string::substr( int32_t start, int32_t len ) {
return reinterpret_cast<const std::string&>(*this).substr(start,len).c_str();
}
const char* string::c_str()const { return reinterpret_cast<const std::string*>(this)->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; }
bool string::operator == ( const char* s )const {
return reinterpret_cast<const std::string&>(*this) == s;
}
bool string::operator == ( const string& s )const {
return reinterpret_cast<const std::string&>(*this) == reinterpret_cast<const std::string&>(s);
}
bool string::operator != ( const string& s )const {
return reinterpret_cast<const std::string&>(*this) != reinterpret_cast<const std::string&>(s);
}
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& c ) {
reinterpret_cast<std::string&>(*this) = reinterpret_cast<const std::string&>(c);
return *this;
}
string& string::operator =( string&& c ) {
reinterpret_cast<std::string&>(*this) = fc::move( reinterpret_cast<std::string&>(c) );
return *this;
}
string& string::operator+=( const string& s ) { *my += *s.my; return *this; }
string& string::operator+=( char c ) { *my += c; return *this; }
string& string::operator+=( const string& s ) {
reinterpret_cast<std::string&>(*this) += reinterpret_cast<const std::string&>(s);
return *this;
}
string& string::operator+=( char c ) {
reinterpret_cast<std::string&>(*this) += c;
return *this;
}
bool operator < ( const string& a, const string& b ) {
return reinterpret_cast<const std::string&>(a) < reinterpret_cast<const std::string&>(b);
}
string operator + ( const string& s, const string& c ) {
return string(s) += c;
}
string operator + ( const string& s, char c ) {
return string(s) += c;
}
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; }
} // namespace fc

2
src/thread.cpp
View file

@ -50,7 +50,7 @@ namespace fc {
}
thread& thread::operator=(thread&& t ) {
fc::swap(t.my,my);
fc_swap(t.my,my);
return *this;
}

11
src/value.cpp
View file

@ -6,7 +6,8 @@
namespace fc {
namespace detail {
struct value_visitor {
class value_visitor {
public:
virtual void operator()( int8_t& v ){};
virtual void operator()( int16_t& v ){};
virtual void operator()( int32_t& v ){};
@ -24,6 +25,8 @@ namespace fc {
virtual void operator()( ){};
};
void value_holder::visit( value::const_visitor&& v )const {v(); }
void value_holder::visit( value_visitor&& v ) {v(); }
// fundamental values...
template<typename T>
@ -47,11 +50,11 @@ namespace fc {
template<>
struct value_holder_impl<void> : value_holder {
value_holder_impl(){};
virtual void visit( value::const_visitor&& v )const{ v(); }
virtual void visit( value_visitor&& v ) { v(); }
// typedef void_t T;
/*
virtual const char* type()const { return "void"; }
virtual void visit( value::const_visitor&& v )const{ v(); }
virtual void visit( value_visitor&& v ) { v(); }
virtual void clear() { }
virtual size_t size()const { return 0; }
@ -127,8 +130,6 @@ namespace fc {
value_holder* value_holder::move_helper( char* c ) { return new(c) value_holder(); }
value_holder* value_holder::copy_helper( char* c )const { return new(c) value_holder(); }
void value_holder::visit( value::const_visitor&& v )const { v(); }
void value_holder::visit( value_visitor&& v ) { v(); }
void value_holder::clear() {}
size_t value_holder::size()const { return 0; }

1
tests/json_rpc_test.cpp
View file

@ -2,6 +2,7 @@
#include <fc/json_rpc_client.hpp>
#include <fc/json_rpc_tcp_server.hpp>
#include <fc/json_rpc_tcp_connection.hpp>
#include <fc/reflect.hpp>
#include <fc/ip.hpp>
#include <fc/iostream.hpp>