~vbursian/research-assistant/intervers

////////////////////////////////////////////////////////////////////////////////
/*! @file Files.cpp   Минимальный интерфейс файловой системы.
- This implementation uses  Qt v.4.6  -  http://qt.nokia.com/
- Part of RANet - Research Assistant Net Library (based on ANSI C++).
- Copyright(C) 2010, Viktor E. Bursian, St.Petersburg, Russia.
                     Viktor.Bursian@mail.ioffe.ru
*///////////////////////////////////////////////////////////////////////////////
#include "Files.h"
#include "Excepts.h"
//#include <unistd.h>  //for getcwd()
#include <QFileInfo>
#include <QFile>
#include <QDir>
#include <QString>
#include <QDateTime>
namespace RA {
//------------------------------------------------------------------------------

inline QString  ToQString (sString S)
{
  return QString::fromUtf8(literal(S));
}


inline sString  FromQString (QString S)
{
  return sString(literal(S.toUtf8()));
}


/*
FromQString( QFileInfo(___).absoluteFilePath() );
*/
//-------------------------------------------------------------------- sPath ---

sString  sPath::Validate (rcsString  S)
{
  return S.Translate(':','_')
          .Translate('*','_')
          .Translate('?','_')
          .Translate('"','_')
          .Translate('<','_')
          .Translate('>','_')
          .Translate('|','_')
          .Translate('\\','_');
}


sString  sPath::ValidateName (rcsString  S)
{
  return sPath::Validate(S).Translate('/','_');
}


sPath::sPath ()
{
}


sPath::sPath (rcsString  path_str)
    :ThePathStr(path_str)
{
}


//sPath::sPath (rcsString  dir
//             ,rcsString  path_relative_to_the_dir)
//{
//}


//sPath::sPath (rcsString  dir
//             ,rcsString  path_relative_to_the_dir
//             ,rcsString  extension)
//{
//}


sPath::sPath (rcsPath  a_path)
    :ThePathStr(a_path.ThePathStr)
{
}


rsPath  sPath::operator = (rcsPath  a_path)
{
  ThePathStr = a_path.ThePathStr;
  return *this;
}


sPath  sPath::Dir () const
{
  sString  dir;
  sString  name;
  sString  extension;
  Split(dir,name,extension);
  return sPath(dir);
}


sString  sPath::Name () const
{
  sString  dir;
  sString  name;
  sString  extension;
  Split(dir,name,extension);
  return name;
}


sString  sPath::Ext () const
{
  sString  dir;
  sString  name;
  sString  extension;
  Split(dir,name,extension);
  return extension;
}


void  sPath::Validate ()
{
  ThePathStr=Validate(ThePathStr);
}


sPath  sPath::CurrentDir ()
{
  sString                     D;
  D=FromQString( QDir::currentPath() );
  return D;
}


bool  sPath::Exists () const
{
  return QFileInfo( ToQString(ThePathStr) ).exists();
}


sTime  sPath::ModificationTime () const
{
  return sTime::FromMillisecondsSinceEpoch(
        QFileInfo( ToQString(ThePathStr) ).lastModified().toMSecsSinceEpoch()
                                          );
}


sTime  sPath::AccessTime () const
{
  return sTime::FromMillisecondsSinceEpoch(
        QFileInfo( ToQString(ThePathStr) ).lastRead().toMSecsSinceEpoch()
                                          );
}


sTime  sPath::CreationTime () const
{
  return sTime::FromMillisecondsSinceEpoch(
        QFileInfo( ToQString(ThePathStr) ).created().toMSecsSinceEpoch()
                                          );
}


bool  sPath::Erase () const
{
  bool                        OK = false;
  OK = QFile::remove( ToQString(ThePathStr) );
  /*! @todo{env} remove empty dirs */
  return OK;
}

//     <cstdio>
//
//int remove ( const char * filename );
//  int i;
//  if (system(NULL)) cout<<"Ok  ";
//    else exit (1);
//  cout << "Executing command mkdir..." << endl;
//  i=system ("mkdir -p ratemp/radata");
//  cout << "The value returned was:" << i << endl;



bool  sPath::CreateDirForIt () const
{
  QDir                        CD(QDir::current());
  bool                        OK = false;
  OK = CD.mkpath( ToQString(Dir().PathStr()) );
  return OK;
}


void  sPath::Split (rsString  dir
                   ,rsString  name
                   ,rsString  extension) const
{
  sString                     tail(ThePathStr);
  size_t                      i=tail.Pos("/");
  while( i < tail.Length() ){
    dir+=tail.Substr(0,i+1);
    tail=tail.Tail(i+1);
    i=tail.Pos("/");
  }
  if( dir.Length() > 1 ){
    dir=dir.Substr(0,dir.Length()-1);
  }
  if( ! tail.Empty() ){
    i=tail.Pos(".");
    while( i < tail.Length() ){
      name+=tail.Substr(0,i+1);
      tail=tail.Tail(i+1);
      i=tail.Pos(".");
    }
    if( name.Length() <= 1 ){
      name+=tail;
    }else{
      name=name.Substr(0,name.Length()-1);
      extension=tail;
    }
  }
}

//-------------------------------------------------------------------- sFile ---

sFile::~sFile()
{
  if( State==Opened ){
    Close();
  }
}


void  sFile::Assign(rcsString fname, eTypeMode type)
{
  if( State == Opened ){
    Close();
    throw xProgramError("sFile::Assign - it is open"
                       ,__FILE__,__LINE__);
  }
  FullName=fname;
  Type=type;
  if( FullName.Empty()  ){
    State=NotAssigned;
  }else{
    State=Closed;
  }
}


void  sFile::Assign(rcsPath   file_path, eTypeMode type)
{
  if( State == Opened ){
    Close();
    throw xProgramError("sFile::Assign - it is open"
                       ,__FILE__,__LINE__);
  }
  FullName=file_path.PathStr();
  Type=type;
  if( FullName.Empty()  ){
    State=NotAssigned;
  }else{
    State=Closed;
  }
}

/*
FILE * fopen ( const char * filename, const char * mode );

Open file
Opens the file whose name is specified in the parameter filename and associates it with a stream that can be identified in future operations by the FILE object whose pointer is returned. The operations that are allowed on the stream and how these are performed are defined by the mode parameter.
The running environment supports at least FOPEN_MAX files open simultaneously; FOPEN_MAX is a macro constant defined in <cstdio>.

Parameters

filename
    C string containing the name of the file to be opened. This paramenter must follow the file name specifications of the running environment and can include a path if the system supports it.
mode
    C string containing a file access modes. It can be:
    "r"	Open a file for reading. The file must exist.
    "w"	Create an empty file for writing. If a file with the same name already exists its content is erased and the file is treated as a new empty file.
    "a"	Append to a file. Writing operations append data at the end of the file. The file is created if it does not exist.
    "r+"	Open a file for update both reading and writing. The file must exist.
    "w+"	Create an empty file for both reading and writing. If a file with the same name already exists its content is erased and the file is treated as a new empty file.
    "a+"	Open a file for reading and appending. All writing operations are performed at the end of the file, protecting the previous content to be overwritten. You can reposition (fseek, rewind) the internal pointer to anywhere in the file for reading, but writing operations will move it back to the end of file. The file is created if it does not exist.


With the mode specifiers above the file is open as a text file. In order to open a file as a binary file, a "b" character has to be included in the mode string. This additional "b" character can either be appended at the end of the string (thus making the following compound modes: "rb", "wb", "ab", "r+b", "w+b", "a+b") or be inserted between the letter and the "+" sign for the mixed modes ("rb+", "wb+", "ab+").
Additional characters may follow the sequence, although they should have no effect. For example, "t" is sometimes appended to make explicit the file is a text file.
In the case of text files, depending on the environment where the application runs, some special character conversion may occur in input/output operations to adapt them to a system-specific text file format. In many environments, such as most UNIX-based systems, it makes no difference to open a file as a text file or a binary file; Both are treated exactly the same way, but differentiation is recommended for a better portability.
For the modes where both read and writing (or appending) are allowed (those which include a "+" sign), the stream should be flushed (fflush) or repositioned (fseek, fsetpos, rewind) between either a reading operation followed by a writing operation or a writing operation followed by a reading operation.
------------------------------------
void fstream::open ( const char * filename,
            ios_base::openmode mode = ios_base::in | ios_base::out );

Open file
Opens a file whose name is s, associating its content with the stream object to perform input/output operations on it. The operations allowed and some operating details depend on parameter mode.

The function effectively calls rdbuf()->open(filename,mode).

If the object already has a file associated (open), the function fails.

On failure, the failbit flag is set (which can be checked with member fail), and depending on the value set with exceptions an exception may be thrown.

Parameters

filename
    C-string containing the name of the file to be opened.
mode
    Flags describing the requested i/o mode for the file. This is an object of type ios_base::openmode, which consists on a combination of one or more of the following flags defined as member constants:
    flag value	opening mode
    app	(append) Set the stream's position indicator to the end of the stream before each output operation.
    ate	(at end) Set the stream's position indicator to the end of the stream on opening.
    binary	(binary) Consider stream as binary rather than text.
    in	(input) Allow input operations on the stream.
    out	(output) Allow output operations on the stream.
    trunc	(truncate) Any current content is discarded, assuming a length of zero on opening.



*/

void  sFile::Open(eOpenMode mode)
{
  if( State == NotAssigned ){
    throw xProgramError("Opening an sFile before it is assigned"
                       ,__FILE__,__LINE__);
  }else if( State == Opened ){
    throw xProgramError("already opened"
                       ,__FILE__,__LINE__);  //"File \"",FullName,"\" already opened"
  }else{
    std::ios_base::openmode          flags;
    switch (mode) {
      case Reading:
              flags= std::ios_base::in;
              break;
      case Writing:
              flags= std::ios_base::out | std::ios_base::trunc;
              break;
      case Updating:
              flags= std::ios_base::in | std::ios_base::out;
              break;
      case Appending:
              flags= std::ios_base::out | std::ios_base::app;
              break;
      default:
              throw xProgramError("",__FILE__,__LINE__);
    };
    if( Type == Binary ){
      flags= flags | std::ios_base::binary;
    };
    open((literal)(QFile::encodeName(ToQString(FullName))),flags);
    if( is_open() ){
      State=Opened;
      Mode=mode;
    }else{
      Mode=mode;//DUMMY FOR DEBUG
      //! @todo{env}      throw xError();
    }
  }
}


void  sFile::Close()
{
  if( State == NotAssigned ){
    throw xProgramError("Closing an sFile before it is assigned"
                       ,__FILE__,__LINE__);
  }else if( State==Closed ){
  }else{
    close();
    State=Closed;
  }
}


//bool  sFile::TryToOpen (eOpenMode mode)
//{
//  try{
//    Open(mode);
//    return true;
//  }catch(...){
//    return false;
//  };
//};
//
//
//bool  sFile::TryToClose ()
//{
//  try{
//    Close();
//    return true;
//  }catch(...){
//    return false;
//  };
//};


//------------------------------------------------------------------------------
} //namespace RA