Stowage/msgpack-python
2
0
Fork 0
mirror of https://github.com/msgpack/msgpack-python.git synced 2026-02-07 02:09:59 +00:00
Code Issues Projects Releases Packages Wiki Activity

rewrite msgpack::object::via

Browse source
This commit is contained in:
frsyuki 2009-02-15 18:39:30 +09:00
parent 6083300ea9
commit 761b398083
11 changed files with 165 additions and 133 deletions
Download patch file Download diff file Expand all files Collapse all files

6
cpp/type/array.hpp
View file

@ -28,9 +28,9 @@ template <typename T>
inline std::vector<T> operator>> (object o, std::vector<T>& v)
{
if(o.type != type::ARRAY) { throw type_error(); }
v.resize(o.via.container.size);
object* p = o.via.container.ptr;
object* const pend = o.via.container.ptr + o.via.container.size;
v.resize(o.via.array.size);
object* p = o.via.array.ptr;
object* const pend = o.via.array.ptr + o.via.array.size;
T* it = &v.front();
for(; p < pend; ++p, ++it) {
p->convert(it);

36
cpp/type/map.hpp
View file

@ -46,13 +46,13 @@ template <typename K, typename V>
inline type::assoc_vector<K,V>& operator>> (object o, type::assoc_vector<K,V>& v)
{
if(o.type != type::MAP) { throw type_error(); }
v.resize(o.via.container.size);
object* p = o.via.container.ptr;
object* const pend = o.via.container.ptr + o.via.container.size;
v.resize(o.via.map.size);
object_kv* p = o.via.map.ptr;
object_kv* const pend = o.via.map.ptr + o.via.map.size;
std::pair<K, V>* it(&v.front());
for(; p < pend; ++it) {
p->convert(&it->first); ++p;
p->convert(&it->second); ++p;
for(; p < pend; ++p, ++it) {
p->key.convert(&it->first);
p->val.convert(&it->second);
}
std::sort(v.begin(), v.end(), type::detail::pair_first_less<K,V>());
return v;
@ -75,18 +75,18 @@ template <typename K, typename V>
inline std::map<K, V> operator>> (object o, std::map<K, V>& v)
{
if(o.type != type::MAP) { throw type_error(); }
object* p(o.via.container.ptr);
object* const pend(o.via.container.ptr + o.via.container.size*2);
while(p < pend) {
object_kv* p(o.via.map.ptr);
object_kv* const pend(o.via.map.ptr + o.via.map.size);
for(; p != pend; ++p) {
K key;
p->convert(&key); ++p;
p->key.convert(&key);
typename std::map<K,V>::iterator it(v.find(key));
if(it != v.end()) {
V val;
p->convert(&val); ++p;
p->val.convert(&val);
it->insert( std::pair<K,V>(key, val) );
} else {
p->convert(&it->second); ++p;
p->val.convert(&it->second);
}
}
return v;
@ -109,12 +109,12 @@ template <typename K, typename V>
inline std::multimap<K, V> operator>> (object o, std::multimap<K, V>& v)
{
if(o.type != type::MAP) { throw type_error(); }
object* p = o.via.container.ptr;
object* const pend = o.via.container.ptr + o.via.container.size*2;
while(p < pend) {
object_kv* p(o.via.map.ptr);
object_kv* const pend(o.via.map.ptr + o.via.map.size);
for(; p != pend; ++p) {
std::pair<K, V> value;
p->convert(&value.first); ++p;
p->convert(&value.second); ++p;
p->key.convert(&value.first);
p->val.convert(&value.second);
v.insert(value);
}
return v;
@ -123,7 +123,7 @@ inline std::multimap<K, V> operator>> (object o, std::multimap<K, V>& v)
template <typename Stream, typename K, typename V>
inline packer<Stream>& operator<< (packer<Stream>& o, const std::multimap<K,V>& v)
{
o.pack_multimap(v.size());
o.pack_map(v.size());
for(typename std::multimap<K,V>::const_iterator it(v.begin()), it_end(v.end());
it != it_end; ++it) {
o.pack(it->first);

10
cpp/type/raw.hpp
View file

@ -27,11 +27,11 @@ namespace msgpack {
namespace type {
struct raw_ref {
raw_ref() : ptr(NULL), size(0) {}
raw_ref(const char* p, uint32_t s) : ptr(p), size(s) {}
raw_ref() : size(0), ptr(NULL) {}
raw_ref(const char* p, uint32_t s) : size(s), ptr(p) {}
const char* ptr;
uint32_t size;
const char* ptr;
std::string str() { return std::string(ptr, size); }
@ -64,8 +64,8 @@ struct raw_ref {
inline type::raw_ref& operator>> (object o, type::raw_ref& v)
{
if(o.type != type::RAW) { throw type_error(); }
v.ptr = o.via.ref.ptr;
v.size = o.via.ref.size;
v.ptr = o.via.raw.ptr;
v.size = o.via.raw.size;
return v;
}

4
cpp/type/tuple.hpp.erb
View file

@ -136,9 +136,9 @@ type::tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>>& operator>> (
object o,
type::tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>>& v) {
if(o.type != type::ARRAY) { throw type_error(); }
if(o.via.container.size < <%=i+1%>) { throw type_error(); }
if(o.via.array.size < <%=i+1%>) { throw type_error(); }
<%0.upto(i) {|j|%>
o.via.container.ptr[<%=j%>].convert<A<%=j%>>(&v.template get<<%=j%>>());<%}%>
o.via.array.ptr[<%=j%>].convert<A<%=j%>>(&v.template get<<%=j%>>());<%}%>
return v;
}
<%}%>