// // MessagePack for C++ static resolution routine // // Copyright (C) 2008-2009 FURUHASHI Sadayuki // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // #ifndef MSGPACK_TYPE_MAP_HPP__ #define MSGPACK_TYPE_MAP_HPP__ #include "msgpack/object.hpp" #include #include #include namespace msgpack { namespace type { template class assoc_vector : public std::vector< std::pair > {}; namespace detail { template struct pair_first_less { bool operator() (const std::pair& x, const std::pair& y) const { return x.first < y.first; } }; } } //namespace type template inline type::assoc_vector& operator>> (object o, type::assoc_vector& v) { if(o.type != type::MAP) { throw type_error(); } 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* it(&v.front()); 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()); return v; } template inline packer& operator<< (packer& o, const type::assoc_vector& v) { o.pack_map(v.size()); for(typename type::assoc_vector::const_iterator it(v.begin()), it_end(v.end()); it != it_end; ++it) { o.pack(it->first); o.pack(it->second); } return o; } template inline std::map operator>> (object o, std::map& v) { if(o.type != type::MAP) { throw type_error(); } 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->key.convert(&key); typename std::map::iterator it(v.find(key)); if(it != v.end()) { V val; p->val.convert(&val); it->insert( std::pair(key, val) ); } else { p->val.convert(&it->second); } } return v; } template inline packer& operator<< (packer& o, const std::map& v) { o.pack_map(v.size()); for(typename std::map::const_iterator it(v.begin()), it_end(v.end()); it != it_end; ++it) { o.pack(it->first); o.pack(it->second); } return o; } template inline std::multimap operator>> (object o, std::multimap& v) { if(o.type != type::MAP) { throw type_error(); } 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 value; p->key.convert(&value.first); p->val.convert(&value.second); v.insert(value); } return v; } template inline packer& operator<< (packer& o, const std::multimap& v) { o.pack_map(v.size()); for(typename std::multimap::const_iterator it(v.begin()), it_end(v.end()); it != it_end; ++it) { o.pack(it->first); o.pack(it->second); } return o; } } // namespace msgpack #endif /* msgpack/type/map.hpp */