TAPsTextFile.cpp

Go to the documentation of this file.

/******************************************************************************
TAPsTextFile.cpp

TextFile is a class for reading/writing/modifying a text file.

SUKITTI PUNAK   (02/17/2006)
UPDATE          (08/26/2009)
******************************************************************************/
#include "TAPsTextFile.hpp"
// Using Inclusion Model (i.e. definitions are included in declarations)
//                       (this name.cpp is included in name.hpp)
// Each friend is defined directly inside its declaration.

BEGIN_NAMESPACE_TAPs
//=============================================================================
// Constructor(s) / Destructor
//-----------------------------------------------------------------------------
TextFile::TextFile () : m_eOpenFileType( Enum::READ )
{}
//-----------------------------------------------------------------------------
TextFile::TextFile ( std::string fileName, Enum::OpenFile type )
    : m_strFileName( fileName ), m_eOpenFileType( type )
{
    switch ( m_eOpenFileType ) {
        case Enum::READ:
            m_inStream.open( m_strFileName.c_str(), std::ios::in );
            if ( !m_inStream.is_open() ) {
                std::cerr << m_strFileName 
                            << " could not be opened for reading!"
                            << std::endl;
            }
            break;
        case Enum::WRITE:
            m_outStream.open( m_strFileName.c_str(), std::ios::out );
            if ( !m_outStream.is_open() ) {
                std::cerr << m_strFileName 
                            << " could not be opened for writing!"
                            << std::endl;
            }
            break;
        case Enum::READ_AND_WRITE:
            std::cerr << "Not Implemented Yet!\n";
            assert( false );
            break;
        default:
            assert( false );
    }
}
//-----------------------------------------------------------------------------
TextFile::~TextFile ()
{
    Close();
}
//-----------------------------------------------------------------------------
//=============================================================================
// Operations
//-----------------------------------------------------------------------------
bool TextFile::ChangeMode ( Enum::OpenFile type )
{
    // Check the supported modes
    if ( type != Enum::READ && type != Enum::WRITE ) {
        std::cerr << "Mode " << type << " for a TextFile object is not supported!";
        return false;
    }

    // Close the open file
    Close();

    // Change the mode and reopen the associated file
    m_eOpenFileType = type;
    switch ( m_eOpenFileType ) {
        case Enum::READ:
            m_inStream.open( m_strFileName.c_str(), std::ios::in );
            if ( !m_inStream.is_open() ) {
                std::cerr << m_strFileName 
                            << " could not be opened for reading!"
                            << std::endl;
            }
            return true;
            break;
        case Enum::WRITE:
            m_outStream.open( m_strFileName.c_str(), std::ios::out );
            if ( !m_outStream.is_open() ) {
                std::cerr << m_strFileName 
                            << " could not be opened for writing!"
                            << std::endl;
            }
            return true;
            break;
        case Enum::READ_AND_WRITE:
            std::cerr << "Not Implemented Yet!\n";
            assert( false );
            break;
        default:
            assert( false );
    }
    return false;
}

bool TextFile::Read ()
{
    if ( !m_inStream.is_open() )    return false;
    return ReadFile();
}
//-----------------------------------------------------------------------------
bool TextFile::Read ( std::string newFileName )
{
    // Close the open file
    Close();

    // Set the new file
    m_strFileName = newFileName;
    switch ( m_eOpenFileType ) {
        case Enum::READ:
            m_inStream.open( m_strFileName.c_str(), std::ios::in );
            if ( !m_inStream.is_open() ) {
                std::cerr << m_strFileName 
                            << " could not be opened for reading!"
                            << std::endl;
            }
            break;
        case Enum::WRITE:
            m_outStream.open( m_strFileName.c_str(), std::ios::out );
            if ( !m_outStream.is_open() ) {
                std::cerr << m_strFileName 
                            << " could not be opened for writing!"
                            << std::endl;
            }
            std::cerr << "The mode is not for reading!" << std::endl;
            return false;
            break;
        case Enum::READ_AND_WRITE:
            std::cerr << "Not Implemented Yet!\n";
            assert( false );
            break;
        default:
            assert( false );
    }

    // Read the file content into the buffer
    if ( !m_inStream.is_open() )    return false;
    return ReadFile();
}
//-----------------------------------------------------------------------------
bool TextFile::Write ()
{
    if ( !m_inStream.is_open() )    return false;
    return WriteFile();
}
//-----------------------------------------------------------------------------
bool TextFile::Write ( std::string newFileName )
{
    // Close the open file
    Close();

    // Set the new file
    m_strFileName = newFileName;
    switch ( m_eOpenFileType ) {
        case Enum::READ:
            m_inStream.open( m_strFileName.c_str(), std::ios::in );
            if ( !m_inStream.is_open() ) {
                std::cerr << m_strFileName 
                            << " could not be opened for reading!"
                            << std::endl;
            }
            std::cerr << "The mode is not for writing!" << std::endl;
            return false;
            break;
        case Enum::WRITE:
            m_outStream.open( m_strFileName.c_str(), std::ios::out );
            if ( !m_outStream.is_open() ) {
                std::cerr << m_strFileName 
                            << " could not be opened for writing!"
                            << std::endl;
            }
            break;
        case Enum::READ_AND_WRITE:
            std::cerr << "Not Implemented Yet!\n";
            assert( false );
            break;
        default:
            assert( false );
    }

    // Write from the buffer into the file
    if ( !m_inStream.is_open() )    return false;
    return WriteFile();
}
//-----------------------------------------------------------------------------
bool TextFile::Write ( std::vector< std::string > const & content )
{
    if ( !m_outStream.is_open() )   return false;
    m_vstrLine = content;
    return WriteFile();
}
//-----------------------------------------------------------------------------
bool TextFile::CopyToFile ( std::string fileName )
{
    if ( !m_outStream.is_open() )   return false;

    // Open the write file
    std::ofstream out;
    out.open( fileName.c_str(), std::ios::out );
    if ( !out.is_open() ) {
        std::cerr << "Couldn't open the file (\"" << fileName << "\")!" << std::endl;
        return false;
    }

    // Write the content to the write file
    std::vector< std::string >::const_iterator pos = m_vstrLine.begin();
    while ( pos != m_vstrLine.end() ) {
        out.write( (*pos).c_str(), static_cast<int>( (*pos).size() ) );
        out << std::endl;
        ++pos;
    }

    // Close the write file
    out.close();

    return true;
}
//-----------------------------------------------------------------------------
bool TextFile::CopyFrom ( TextFile const & src )
{
    if ( !m_outStream.is_open() )   return false;
    this->m_vstrLine = src.m_vstrLine;
    return WriteFile();
}
//-----------------------------------------------------------------------------
bool TextFile::Close ()
{
    if ( m_inStream.is_open() )     m_inStream.close();
    if ( m_outStream.is_open() )    m_outStream.close();
    return true;
}
//-----------------------------------------------------------------------------
//=============================================================================
// START: PROTECTED PART
//-----------------------------------------------------------------------------
bool TextFile::ReadFile ()
{
    m_inStream.seekg( 0 );      // beginning of the file
    m_vstrLine.clear();         // clear read lines
    char *cStr = new char[ 256 ];
    while ( m_inStream && !m_inStream.eof() ) {
        m_inStream.getline( cStr, 256 ); // read a line with 256 chars limit
        assert( m_inStream.gcount() <= 256 );
        m_vstrLine.push_back( std::string( cStr ) );
    }
    delete [] cStr;
    return true;
}
//-----------------------------------------------------------------------------
bool TextFile::WriteFile ()
{
    std::vector< std::string >::const_iterator pos = m_vstrLine.begin();
    while ( pos != m_vstrLine.end() ) {
        m_outStream.write( (*pos).c_str(), static_cast<int>( (*pos).size() ) );
        m_outStream << std::endl;
        ++pos;
    }
    return true;
}
//-----------------------------------------------------------------------------
// END: PROTECTED PART
//=============================================================================
END_NAMESPACE_TAPs
//34567890123456789012345678901234567890123456789012345678901234567890123456789
//--+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----