valarray.hpp
Go to the documentation of this file.00001
00002
00003
00004
00005
00006 #ifndef s11n_VALARRAY_HPP_INCLUDED
00007 #define s11n_VALARRAY_HPP_INCLUDED 1
00008
00009 #include <stdio.h>
00010 #include <valarray>
00011 #include <s11n.net/s11n/variant.hpp>
00012
00013 namespace s11n {
00014
00015
00016
00017
00018
00019 namespace va {
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038
00039
00040
00041
00042
00043
00044
00045
00046
00047
00048
00049 template <typename NodeT, typename VAT>
00050 bool serialize_valarray( NodeT & dest, const VAT & src )
00051 {
00052 typedef s11n::node_traits<NodeT> TR;
00053 TR::class_name( dest, ::s11n::s11n_traits<VAT>::class_name(&src) );
00054 const int buffsize = 9;
00055 char num[buffsize];
00056 char fmt[buffsize];
00057 size_t sz = src.size();
00058 int places = 1;
00059 for( ; sz >= 0x0f; sz = (size_t)(sz/0x0f)) { ++places; }
00060 if( places > (buffsize-1) )
00061 {
00062 throw ::s11n::s11n_exception( "%s:%d: Internal error: overflow in serialize_valarray(). Too many items in valarray.", __FILE__,__LINE__);
00063 }
00064 snprintf( fmt, buffsize, "x%%0%dx", places );
00065 sz = src.size();
00066 TR::set( dest, "size", sz );
00067 for( size_t i = 0 ; i < sz; i++ )
00068 {
00069 snprintf( num, buffsize, fmt, i );
00070 TR::set( dest, num, src[i] );
00071 }
00072 return true;
00073 }
00074
00075
00076
00077
00078
00079
00080
00081
00082 template <typename NodeT, typename VAT>
00083 bool deserialize_valarray( const NodeT & src, VAT & dest )
00084 {
00085 typedef ::s11n::node_traits<NodeT> TR;
00086 typedef typename VAT::value_type VT;
00087 typename TR::property_map_type::const_iterator it = TR::properties(src).begin();
00088 typename TR::property_map_type::const_iterator et = TR::properties(src).end();
00089 const static std::string szkey = "size";
00090 size_t size = TR::get( src, szkey, dest.size() );
00091 VT defaultval;
00092 dest.resize( size, defaultval );
00093 size_t i = 0;
00094 for( ; et != it; ++it )
00095 {
00096 if( szkey == (*it).first ) continue;
00097 dest[i++] = ::s11n::Detail::variant( (*it).second ).template cast_to<VT>( defaultval );
00098 }
00099 return true;
00100 }
00101
00102
00103
00104
00105 struct valarray_serializable_proxy
00106 {
00107
00108 valarray_serializable_proxy()
00109 {}
00110
00111
00112
00113
00114
00115 template <typename NodeType, typename SerType>
00116 bool operator()( NodeType & dest, const SerType & src ) const
00117 {
00118 return serialize_valarray( dest, src );
00119 }
00120
00121
00122 template <typename NodeType, typename SerType>
00123 bool operator()( const NodeType & src, SerType & dest ) const
00124 {
00125 return deserialize_valarray( src, dest );
00126 }
00127 };
00128
00129 }
00130
00131
00132
00133
00134
00135
00136 template <typename ValueType>
00137 struct s11n_traits < std::valarray<ValueType> >
00138 {
00139 typedef std::valarray<ValueType> serializable_type;
00140 typedef ::s11n::va::valarray_serializable_proxy serialize_functor;
00141 typedef serialize_functor deserialize_functor;
00142 typedef ::s11n::cl::object_factory<serializable_type> factory_type;
00143 typedef ::s11n::default_cleanup_functor<serializable_type> cleanup_functor;
00144 static bool cl_reg_placeholder;
00145 static std::string class_name( const serializable_type * instance_hint )
00146 {
00147 if( cl_reg_placeholder == true );
00148 return "valarray";
00149 }
00150 };
00151
00152 template <typename VT>
00153 bool s11n_traits< std::valarray< VT > >::cl_reg_placeholder =
00154 (
00155 ::s11n::cl::classloader_register_base<std::valarray< VT > >( s11n_traits< std::valarray< VT > >::class_name(0) )
00156 , 0 );
00157
00158
00159 }
00160
00161
00162
00163 #endif // s11n_VALARRAY.HPP_HPP_INCLUDED