#pragma once
/////////////////////////////////////////////////////////////
// std_serialize: serizlization of collections onto archive
//
// define operator << and >> from ar with:
// std::list, std::vector, std::pair,
// std::map, std::hash_map, std::set
//
// require the value types to have << and >> operator themselves
//
namespace std
{
template <class T>
CArchive& operator<<(CArchive& ar, const std::list<T>& lst)
{
ar << (ULONG)lst.size();
std::list<T>::const_iterator I;
for(I=lst.begin(); I!=lst.end(); I++)
ar << *I;
return ar;
}
template <class T>
CArchive& operator>>(CArchive& ar, std::list<T>& lst)
{
lst.clear();
ULONG size; ar >> size;
while(size--)
{
T element; ar >> element;
lst.push_back(element);
}
return ar;
}
template <class T>
CArchive& operator<<(CArchive& ar, const std::vector<T>& v)
{
ar << (ULONG)v.size();
std::vector<T>::const_iterator I;
for(I=v.begin(); I!=v.end(); I++)
ar << *I;
return ar;
}
template <class T>
CArchive& operator>>(CArchive& ar, std::vector<T>& v)
{
v.clear();
ULONG size; ar >> size;
v.resize(size);
std::vector<T>::iterator I = v.begin();
while(size--)
{
ar >> *I;
I++;
}
ASSERT(I == v.end());
return ar;
}
template <class T, class U>
CArchive& operator<<(CArchive& ar, const std::pair<T,U>& c)
{
ar << c.first << c.second;
return ar;
}
template <class T, class U>
CArchive& operator>>(CArchive& ar, std::pair<T,U>& c)
{
ar >> c.first >> c.second;
return ar;
}
template<class K, class T, class Pr>
CArchive& operator<<(CArchive& ar, const std::map<K,T,Pr>& m)
{
ar << (ULONG)m.size();
std::map<K,T,Pr>::const_iterator I;
for(I=m.begin(); I!=m.end(); I++)
ar << *I;
return ar;
}
template<class K, class T, class Pr>
CArchive& operator>>(CArchive& ar, std::map<K,T,Pr>& m)
{
m.clear();
ULONG size; ar >> size;
while(size--)
{
std::pair<K,T> val;
ar >> val;
m.insert(val);
}
return ar;
}
template<class K, class T, class Pr>
CArchive& operator<<(CArchive& ar, const std::hash_map<K,T,Pr>& m)
{
ar << (ULONG)m.size();
std::map<K,T,Pr>::const_iterator I;
for(I=m.begin(); I!=m.end(); I++)
ar << *I;
return ar;
}
template<class K, class T, class Pr>
CArchive& operator>>(CArchive& ar, std::hash_map<K,T,Pr>& m)
{
m.clear();
ULONG size; ar >> size;
while(size--)
{
std::pair<K,T> val;
ar >> val;
m.insert(val);
}
return ar;
}
template<class K, class Pr>
CArchive& operator<<(CArchive& ar, const std::set<K,Pr>& s)
{
ar << (ULONG)s.size();
std::set<K, Pr>::const_iterator I;
for(I=s.begin(); I!=s.end(); I++)
ar << *I;
return ar;
}
template<class K, class Pr>
CArchive& operator>>(CArchive& ar, std::set<K,Pr>& s)
{
s.clear();
ULONG size; ar >> size;
while(size--)
{
K val; ar >> val;
s.insert(val);
}
return ar;
}
};