/////////////////////////////////////////////////////////////////
//  serialize.cpp - defines serialization interface and class  //
//  Exam3:Q1                                                   //
//  Jim Fawcett, CSE687 - Object Oriented Design, Spring 05    //
/////////////////////////////////////////////////////////////////

#include <string>
#include <iostream>
#include <sstream>
#include <fstream>

/////////////////////////////////////////////////////////////////
// answer starts here

template <typename U, typename V>
class persistent : public U
{
public:
  persistent() {}
  persistent(const U& u) : U(u) {}
  virtual ~persistent() {}
  virtual void serialize(std::ostream& os) = 0;
  virtual V deserialize(std::istream& is) = 0;
};

class persistentString 
  : public persistent<std::string,persistentString>
{
public:
  persistentString(const std::string& s) 
    : persistent<std::string,persistentString>(s) {}
  
  virtual void serialize(std::ostream& os)
  {
    for(unsigned int i=0; i<size(); ++i)
      os.put((*this)[i]);
    os.flush();
  }

  virtual persistentString deserialize(std::istream& is)
  {
    while(is.good())
    {
      this->append(1,is.get());
    }
    return *this;
  }
};

// end of answer
/////////////////////////////////////////////////////////////
// The remaining code is here for my own amusement

class persistentStringStream;

template<> 
persistent<std::ostringstream,persistentStringStream>
  ::persistent(const std::ostringstream& ss)
{
  str(ss.str());
}

class persistentStringStream 
  : public persistent<std::ostringstream,persistentStringStream>
{
public:
  persistentStringStream(const std::ostringstream& s) 
    : persistent<std::ostringstream,persistentStringStream>(s) {}
  
  persistentStringStream() {}

  persistentStringStream(const std::string& s)
  {
    static_cast<std::ostringstream*>(this)->str(s);
  }

  virtual void serialize(std::ostream& os)
  {
    std::string temp = this->str();
    for(unsigned int i=0; i<temp.size(); ++i)
      os.put(temp[i]);
    os.flush();
  }

  virtual persistentStringStream deserialize(std::istream& is)
  {
    while(is.good())
    {
      this->put(is.get());
    }
    return *this;
  }
};
// end of amusement
/////////////////////////////////////////////////////////////

void main()
{
  persistentString ps = "\n  now is the hour";
  std::ofstream out("temp.dat");
  ps.serialize(std::cout);
  ps.serialize(out);
  out.close();

  std::ifstream in("temp.dat");
  ps.deserialize(in);
  std::cout << ps.c_str() << "\n\n";
  in.close();

  ///////////////////////////////////////////////////////////
  // more amusement follows

  persistentStringStream pss("\n  persistentStringStream: ");
  pss.seekp(0,std::ios::end);
  pss << 15 << " " << 3.1415927;
  out.open("temp.dat");
  pss.serialize(std::cout);
  pss.serialize(out);
  out.close();

  in.open("temp.dat");
  pss.deserialize(in);
  std::cout << pss.str().c_str() << "\n\n";
  in.close();
}