stringserialization.h

Go to the documentation of this file.

#ifndef STRINGSERIALIZATION_H
#define STRINGSERIALIZATION_H

#include <string>
#include <sstream>
#include <vector>
using namespace std;

#include <typedefs.h>

//  String serialization classes.
//  See http://en.wikipedia.org/wiki/Serialization 

class vectorstring
{
public:

  template< typename T >
  static boolc serialize(string & str, vector<T> const & v);
  template< typename T >
  static boolc deserialize(vector<T> & v, stringc & str);

  template< typename T >
  static void serializeInverse(vector<T> & v, stringc & str)
    { deserialize(v,str); };
 

};

class filestring
{
public:

  static boolc serialize(string & str, stringc & filename);
  static boolc deserialize(stringc & filename, stringc & str);
  static boolc serializeInverse(stringc & filename, stringc & str);
};

class vectorfile
{
public:

  template< typename T >
  static boolc serialize(string & filename, vector<T> const & v);
  template< typename T >
  static boolc deserialize(vector<T> & v, stringc & filename);

};

class htmlstring
{
public:

  static string lessthan;
  static string greaterthan;
  static string amp;
  static string quot;

  static boolc serialize(string & str, stringc & html );
  static boolc serializeInverse(string & html, stringc & str );

  static boolc ishtml(stringc & str);

  


};




//---------------------------------------------------------
//  Implementation.

template< typename T >
boolc vectorstring::serialize(string & str, vector<T> const & v)
{
  uintc vsz=v.size();
  str="";
  stringc space(" ");
  
  for (uint i=0; i<vsz; ++i)
  {
    stringstream targ;
    targ << v[i];
    if (targ.good()==false)
      return false;
   
    str += (targ.str()+space);
  }

  return true;
}

template< typename T >
boolc vectorstring::deserialize(vector<T> & v, stringc & str)
{
  stringstream targ(str);
  if (targ.good()==false)
    return false;

  bool process=true;
  T val;
  for (;process; )
  {
    targ >> val;
    // The end of input must fail.
    if (targ.fail())
    {
      // If it is not the end of the data stream return false.
      if (!targ.eof())
        return false;

      // Do not add the last element twice.
      process=false;
    }
    else
      v.push_back(val);
  }
  
  return true;
}

template< typename T >
boolc vectorfile::serialize(string & filename, vector<T> const & v)
{
  bool result;
  string str;
  result=vectorstring::serialize(str,v);
  if (result==false)
    return false;

  result=filestring::deserialize(filename,str);
  if (result==false)
    return false;

  return true;
}

template< typename T >
boolc vectorfile::deserialize(vector<T> & v, stringc & filename)
{
  bool result;
  string str;
  result=filestring::serialize(str,filename);
  if (result==false)
    return false;

  result=vectorstring::deserialize(v,str);
  if (result==false)
    return false;

  return true;
}


#endif