Tanl Linguistic Pipeline

tag/Tanlpos/serialization.h

/*
**  Tanl
**  tag/TanlPos/serialization.h
**  ----------------------------------------------------------------------
**  Copyright (c) 2005  Giuseppe Attardi (attardi@di.unipi.it).
**  ----------------------------------------------------------------------
**
**  This file is part of Tanl.
**
**  Tanl is free software; you can redistribute it and/or modify it
**  under the terms of the GNU General Public License, version 3,
**  as published by the Free Software Foundation.
**
**  Tanl is distributed in the hope that it will be useful,
**  but WITHOUT ANY WARRANTY; without even the implied warranty of
**  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
**  GNU General Public License for more details.
**
**  You should have received a copy of the GNU General Public License
**  along with this program.  If not, see <http://www.gnu.org/licenses/>.
**  ----------------------------------------------------------------------
*/

#ifndef Tanl_POS_serialization_H
#define Tanl_POS_serialization_H

#include <iostream>
#include <map>
#include <string>
#include <vector>

namespace Tanl { namespace POS {
    
//
// Serialization of basic types.
//

// FIXME: should care of byte ordering.
template<class _T>
void serialize(const _T& x, std::ostream& out)
{
# ifdef DEBUG
  std::cerr << x << std::endl;
# endif
  out.write((char*)&x, sizeof(_T));
}

// FIXME: should care of byte ordering.
template<class _T>
void serialize(_T& x, std::istream& in)
{
  in.read((char*)&x, sizeof(_T));
}

template<>
void serialize<std::pair<int, int> >(const std::pair<int, int>& x, std::ostream& out);

template<>
void serialize<std::pair<int, int> >(std::pair<int, int>& x, std::istream& in);

template<>
void serialize<std::string>(const std::string& x, std::ostream& out);

template<>
void serialize<std::string>(std::string& x, std::istream& in);

template<class _K, class _T>
void serialize(const std::map<_K, _T>& x, std::ostream& out)
{
  std::size_t size = x.size();
  out.write((char*)&size, sizeof(size));
  typename std::map<_K, _T>::const_iterator it = x.begin();
  for (; it != x.end(); it++) {
    serialize(it->first, out);
    serialize(it->second, out);
  }
}

template<class _K, class _T>
void serialize(std::map<_K, _T>& x, std::istream& in)
{
  std::size_t size = 0;
  in.read((char*)&size, sizeof(size));
  while (size-- > 0) {
    _K first;
    serialize(first, in);
    _T second;
    serialize(second, in);
    x[first] = second;
  }
}

template<class _T>
void serialize(const std::vector<_T>& x, std::ostream& out)
{
  std::size_t size = x.size();
  out.write((char *)(&size), sizeof(std::size_t));
  typename std::vector<_T>::const_iterator it = x.begin();
  for (; it != x.end(); it++)
    serialize(*it, out);
}

template<class _T>
void serialize(std::vector<_T>& x, std::istream& in)
{
  std::size_t size = 0;
  in.read((char *)(&size), sizeof(std::size_t));
  while (size-- > 0) {
    _T t;
    serialize(t, in);
    x.push_back(t);
  }
}
    
}
}

#endif // Tanl_POS_serialization_H

 

Copyright © 2005-2011 G. Attardi. Generated on 4 Mar 2011 by doxygen 1.6.1.