/* memstream.cc */

#include "memstream.h"
#include "ioexception.h"
#include "inf.h" // function info

#include <string.h> // function strcmp

#include <fstream>

OPEN_NAMESPACE

/* ---------------------------------------------------------------------- */

void MemStream::open (string p_file_name)
{
   file_name = p_file_name;
}

string MemStream::get_file_name ()
{
   return file_name;
}

string MemStream::get_text ()
{
   return this->str();
}

void MemStream::EnableOutputMessages (bool value)
{
   show_msg = value;
}

MemStream::MemStream () :
   file_name (),
   show_msg (true)
{ }

/* ---------------------------------------------------------------------- */

void MemStream::write_text ()
{
   ofstream f (file_name.c_str ());
   if (! f.good ())
      error ("Cannot open file for writing", file_name, 0, 0);

   f << this->str ();

   f.close ();
   if (! f.good ())
      error ("Error writing file", file_name, 0, 0);
}

/* ---------------------------------------------------------------------- */

void MemStream::store ()
{
   this->flush ();

   bool equal = false;

   {
      ifstream f (file_name.c_str ());
      if (f.good ())
      {
         f.seekg (0, ifstream::end);

         streamsize size = f.tellg (); // MANDRAKE 9.0 (int)

         string text = this->str();
         size_t text_length = text.length ();

         if (size >= 0 && size == text_length)
         {
            char * data = new char [size+1];
            f.seekg (0, ifstream::beg);
            f.read (data, size);

            streamsize size2 = f.gcount ();
            if (size2 == size)
            {
                data [size] = 0;
                if (strcmp (text.c_str (), data) == 0)
                   equal = true;
            }

            delete [] data; // do not forget []
         }

         f.close ();
      }
   }

   if (! equal)
   {
      write_text ();
      if (show_msg)
         info ("writing " + file_name);
   }
   else
   {
      if (show_msg)
         info ("not modified " + file_name);
   }

}

void MemStream::store_always ()
{
   write_text ();
   if (show_msg)
      info ("unconditionally writing " + file_name);
}

/* ---------------------------------------------------------------------- */

bool MemStream::read_from (string p_file_name)
{
   ifstream f (p_file_name.c_str ());

   if (f.good ())
   {
      f.seekg (0, ifstream::end);
      size_t size = f.tellg ();

      if (size >= 0)
      {
         char * data = new char [size];
         f.seekg (0, ifstream::beg);
         f.read (data, size);

         this->write (data, size);
         delete data;
      }
   }

   return f.good ();
}

/* ---------------------------------------------------------------------- */

CLOSE_NAMESPACE