IFStreamAscii.h

Go to the documentation of this file.

//- ****************************************************************************
//- 
//- Copyright 2009 Sandia Corporation. Under the terms of Contract
//- DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government
//- retains certain rights in this software.
//- 
//- BSD Open Source License.
//- All rights reserved.
//- 
//- Redistribution and use in source and binary forms, with or without
//- modification, are permitted provided that the following conditions are met:
//- 
//-    * Redistributions of source code must retain the above copyright notice,
//-      this list of conditions and the following disclaimer.
//-    * Redistributions in binary form must reproduce the above copyright
//-      notice, this list of conditions and the following disclaimer in the
//-      documentation and/or other materials provided with the distribution.
//-    * Neither the name of Sandia National Laboratories nor the names of its
//-      contributors may be used to endorse or promote products derived from
//-      this software without specific prior written permission.
//- 
//- THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
//- AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
//- IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
//- ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
//- LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
//- CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
//- SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
//- INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
//- CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
//- ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
//- POSSIBILITY OF SUCH DAMAGE.
//-
//- ****************************************************************************
 
#ifndef IFSTREAMASCII_OBJECT_H
#define IFSTREAMASCII_OBJECT_H
 
// **** _SYSTEM INCLUDES_ ******************************************************
 
#include <iostream>
#include <string>
#include <fstream>
#include <vector>
#include <sstream>
 
// use standard library objects
using namespace std;
 
// **** _LOCAL INCLUDES_ *******************************************************
 
#include "CPPUtils.h"
#include "GeoTessUtils.h"
#include "GeoTessException.h"
 
// **** _BEGIN GEOTESS NAMESPACE_ **********************************************
 
namespace geotess {
 
// **** _FORWARD REFERENCES_ ***************************************************
 
// **** _CLASS DEFINITION_ *****************************************************
 
class GEOTESS_EXP_IMP IFStreamAscii
{
  private:
 
        ifstream            ifs;
 
        ofstream            ofs;
 
    string                      strDelim[5];
 
        string                      strFileName;
 
    // The total number of lines read from this stream
    int                             strTotlLinesRead;
    // The total number of "data" lines read from this stream
    int                             strDataLinesRead;
    // The total number of "blank" lines read from this stream
    int                             strBlankLinesRead;
    // The total number of "comment" lines read from this stream
    int                             strCommentLinesRead;
    // The total number of "block comment" lines read from this stream
    int                             strBlkCommentLinesRead;
    // The total number of "bytes" read from this stream
    int                             strBytesRead;
 
    bool                            strBlkCommntSet;
 
    int                             strTokenPtr;
 
    vector<string>      strTokens;
 
    public:
 
    void                            getLine(string& buf);
 
    void getline(string& s) { std::getline(ifs, s); };
 
                                            IFStreamAscii() :   strFileName(""), strTotlLinesRead(0),
                                                                                strDataLinesRead(0), strBlankLinesRead(0),
                                                                                strCommentLinesRead(0), strBlkCommentLinesRead(0),
                                                                                strBytesRead(0), strBlkCommntSet(false),
                                                                                strTokenPtr(0)
                                            {setDefaultDelimiters(); setCommentDelimiter("#"); };
 
        virtual                     ~IFStreamAscii() { close(); };
 
        void                            openForRead(const string& fn);
        void                            openForWrite(const string& fn);
 
        bool                            isOpen() { return (ifs.is_open() || ofs.is_open()) ? true : false; }
 
        void                            close()
                                            {
                                                if (ifs.is_open())
                                                    ifs.close();
                                                else if (ofs.is_open())
                                                    ofs.close();
                                            }
 
        void                            flush()
                                            {
                                                if (ofs.is_open())
                                                    ofs.flush();
                                            }
 
        bool                            read(string& token);
 
        bool                            readLine(string& ln);
 
        void                            tokenize(const string& str, vector<string>& tokens);
 
        const string&           getFileName() const { return strFileName; };
 
        void                            setDefaultDelimiters();
 
        void                            resetReader();
 
        void                            setDelimiters(const string& wspcDelims,
                                                                        const string& strgDelim,
                                                                        const string& cmntDelim,
                                                                        const string& begBlk,
                                                                        const string& endBlk)
        {
            strDelim[0] = wspcDelims;
            strDelim[1] = strgDelim;
            strDelim[2] = cmntDelim;
            strDelim[3] = begBlk;
            strDelim[4] = endBlk;
        }
 
        void                        setWhitespaceDelimiters(const string& wsDelims)
                                        { strDelim[0] = wsDelims; };
 
        const string&       getWhitespaceDelimiters() const
                                        { return strDelim[0]; };
 
        void                        setStringDelimiter(const string& strgDelim)
                                        { strDelim[1] = strgDelim; };
 
        const string&       getStringDelimiter() const
                                        { return strDelim[1]; };
 
        void                        setCommentDelimiter(const string& cmntDelim)
                                        { strDelim[2] = cmntDelim; };
 
        const string&       getCommentDelimiter() const
                                        { return strDelim[2]; };
 
        void                            setBlockCommentDelimiters(const string& begBlk,
                                                                                                const string& endBlk)
        {
            strDelim[3] = begBlk;
            strDelim[4] = endBlk;
        }
 
        void                            setBeginBlockCommentDelimiter(const string& begBlkCmntDelim)
                                            { strDelim[3] = begBlkCmntDelim; };
 
        const string&           getBeginBlockCommentDelimiter() const
                                            {   return strDelim[3]; };
 
        void                            setEndBlockCommentDelimiter(const string& endBlkCmntDelim)
                                            { strDelim[4] = endBlkCmntDelim; };
 
        const string&           getEndBlockCommentDelimiter() const
                                            {   return strDelim[4]; };
 
        int                             getTotalLinesRead() const
                                            {   return strTotlLinesRead; };
 
        int                             getDataLinesRead() const
                                            { return strDataLinesRead; };
 
        int                             getBlankLinesRead() const
                                            { return strBlankLinesRead; };
 
        int                             getCommentLinesRead() const
                                            { return strCommentLinesRead; };
 
        int                             getBlockCommentLinesRead() const
                                            { return strBlkCommentLinesRead; };
 
        int                             getBytesRead() const
                                            { return strBytesRead; };
 
        bool                            isEOF() const;
 
        bool                            next();
 
        string                      readString();
 
        bool                            readString(string& s);
 
        byte                            readByte();
 
        bool                            readType(byte& b) { return readByte(b); };
 
        bool                            readByte(byte& b);
 
        short                           readShort();
 
        bool                            readType(short& s) { return readShort(s); };
 
        bool                            readShort(short& s);
 
        int                             readInteger();
 
        bool                            readType(int& i) { return readInteger(i); };
 
        bool                            readInteger(int& i);
 
        LONG_INT                            readLong();
 
        bool                            readType(LONG_INT& l) { return readLong(l); };
 
        bool                            readLong(LONG_INT& l);
 
        float                           readFloat();
 
        bool                            readType(float& f) { return readFloat(f); };
 
        bool                            readFloat(float& f);
 
        double                      readDouble();
 
        bool                            readType(double& d) { return readDouble(d); };
 
        bool                            readDouble(double& d);
 
        // ***** Write functions **************************************************
 
        void                            writeString(const string& s) {ofs << s;}
        void                            writeStringNL(const string& s) {ofs << s << endl;}
        void                            writeType(const string& s) {ofs << s;}
        void                            writeTypeNL(const string& s) {ofs << s << endl;}
        void                            writeBool(bool b) {ofs << b;}
        void                            writeBoolNL(bool b) {ofs << b << endl;}
        void                            writeType(bool b) {ofs << b;}
        void                            writeTypeNL(bool b) {ofs << b << endl;}
        void                            writeByte(byte b) {ofs << (int)b;}
        void                            writeByteNL(byte b) {ofs << (int)b << endl;}
        void                            writeType(byte b) {ofs << (int)b;}
        void                            writeTypeNL(byte b) {ofs << (int)b << endl;}
        void                            writeShort(short s) {ofs << s;}
        void                            writeShortNL(short s) {ofs << s << endl;}
        void                            writeType(short s) {ofs << s;};
        void                            writeTypeNL(short s) {ofs << s << endl;};
        void                            writeInt(int i) {ofs << i;}
        void                            writeIntNL(int i) {ofs << i << endl;}
        void                            writeType(int i) {ofs << i;}
        void                            writeTypeNL(int i) {ofs << i << endl;}
        void                            writeLong(LONG_INT l) {ofs << l;}
        void                            writeLongNL(LONG_INT l) {ofs << l << endl;}
        void                            writeType(LONG_INT l) {ofs << l;}
        void                            writeTypeNL(LONG_INT l) {ofs << l << endl;}
        void                            writeFloat(float f) {ofs << f;}
        void                            writeFloatNL(float f) {ofs << f << endl;}
        void                            writeType(float f) {ofs << f;}
        void                            writeTypeNL(float f) {ofs << f << endl;}
        void                            writeDouble(double d) {ofs << d;}
        void                            writeDoubleNL(double d) {ofs << d << endl;}
        void                            writeType(double d) {ofs << d;}
        void                            writeTypeNL(double d) {ofs << d << endl;}
        void                            writeNL() {ofs << endl;}
 
}; // end class IFStreamAscii
 
inline bool IFStreamAscii::read(string& token)
{
  string ln;
 
  // if the strTokenPtr is >= than strTokens.size() then get more tokens
 
  if (strTokenPtr >= (int) strTokens.size())
  {
    // get more tokens ... reset token pointer and list
 
    strTokenPtr = 0;
    strTokens.clear();
 
    // read another data line from the stream ... if eof() is reached return
    // true
 
    if (!readLine(ln)) return false;
 
    // tokennize the line into the tokens list
 
    tokenize(ln, strTokens);
  }
 
  // get the token ... increment the pointer ... and return false for success
 
  token = strTokens[strTokenPtr++];
  return true;
}
 
inline bool IFStreamAscii::isEOF() const
{
  return (ifs.eof() && (strTokenPtr >= (int) strTokens.size()));
}
 
inline string IFStreamAscii::readString()
{
    string s;
  read(s);
    return s;
}
 
inline bool IFStreamAscii::readString(string& s)
{
  return read(s);
}
 
inline bool IFStreamAscii::next()
{
    string s;
  return read(s);
}
 
inline byte IFStreamAscii::readByte()
{
    byte b = 0;
    readByte(b);
    return b;
}
 
inline bool IFStreamAscii::readByte(byte& b)
{
  string sb;
 
  // read token into sb ... if eof or stream not open return false
 
  if (!read(sb)) return false;
 
  // attempt to scan token into b ... if unable issue error and return false
 
  if (sscanf(sb.c_str(), "%hhd", &b) != 1)
  {
    ostringstream os;
        os << endl << "ERROR in IFStreamAscii::readByte" << endl
             << "  Could Not Scan Byte From Token = " << sb << endl
       << "  On File Line: " << strTotlLinesRead << " ..." << endl;
    throw GeoTessException(os, __FILE__, __LINE__, 9201);
  }
 
  // successful ... return true
 
  return true;
}
 
inline short IFStreamAscii::readShort()
{
    short s = 0;
    readShort(s);
    return s;
}
 
inline bool IFStreamAscii::readShort(short& s)
{
  string ss;
 
  // read token into ss ... if eof or stream not open return false
 
  if (!read(ss)) return false;
 
  // attempt to scan token into s ... if unable issue error and return false
 
  if (sscanf(ss.c_str(), "%hd", &s) != 1)
  {
    ostringstream os;
        os << endl << "ERROR in IFStreamAscii::readShort" << endl
             << "  Could Not Scan Short From Token = " << ss << endl
       << "  On File Line: " << strTotlLinesRead << " ..." << endl;
    throw GeoTessException(os, __FILE__, __LINE__, 9202);
  }
 
  // successful ... return true
 
  return true;
}
 
inline int IFStreamAscii::readInteger()
{
    int i = 0;
    readInteger(i);
    return i;
}
 
inline bool IFStreamAscii::readInteger(int& i)
{
  string si;
 
  // read token into si ... if eof or stream not open return false
 
  if (!read(si)) return false;
 
  // attempt to scan token into i ... if unable issue error and return false
 
  if (sscanf(si.c_str(), "%d", &i) != 1)
  {
    ostringstream os;
        os << endl << "ERROR in IFStreamAscii::readInteger" << endl
             << "  Could Not Scan Integer From Token = " << si << endl
       << "  On File Line: " << strTotlLinesRead << " ..." << endl;
    throw GeoTessException(os, __FILE__, __LINE__, 9203);
  }
 
  // successful ... return true
 
  return true;
}
 
inline LONG_INT IFStreamAscii::readLong()
{
    LONG_INT l = 0;
    readLong(l);
    return l;
}
 
inline bool IFStreamAscii::readLong(LONG_INT& l)
{
  string sl;
 
  // read token into sl ... if eof or stream not open return false
 
  if (!read(sl)) return false;
 
  // attempt to scan token into l ... if unable issue error and return false
 
  if (sscanf(sl.c_str(), LONG_INT_F, &l) != 1)
  {
    ostringstream os;
        os << endl << "ERROR in IFStreamAscii::readLong" << endl
             << "  Could Not Scan Long From Token = " << sl << endl
       << "  On File Line: " << strTotlLinesRead << " ..." << endl;
    throw GeoTessException(os, __FILE__, __LINE__, 9204);
  }
 
  // successful ... return true
 
  return true;
}
 
inline float IFStreamAscii::readFloat()
{
    float f = 0;
    readFloat(f);
    return f;
}
 
inline bool IFStreamAscii::readFloat(float& f)
{
  string sf;
 
  // read token into sf ... if eof or stream not open return false
 
  if (!read(sf)) return false;
 
  // attempt to scan token into f ... if unable issue error and return false
 
  if (sscanf(sf.c_str(), "%f", &f) != 1)
  {
    ostringstream os;
        os << endl << "ERROR in IFStreamAscii::readFloat" << endl
             << "  Could Not Scan Float From Token = " << sf << endl
       << "  On File Line: " << strTotlLinesRead << " ..." << endl;
    throw GeoTessException(os, __FILE__, __LINE__, 9205);
  }
 
  // successful ... return true
 
  return true;
}
 
inline double IFStreamAscii::readDouble()
{
    double d = 0;
    readDouble(d);
    return d;
}
 
inline bool IFStreamAscii::readDouble(double& d)
{
  string sd;
 
  // read token into sd ... if eof or stream not open return false
 
  if (!read(sd)) return false;
 
  // attempt to scan token into d ... if unable issue error and return false
 
  if (sscanf(sd.c_str(), "%lf", &d) != 1)
  {
    ostringstream os;
        os << endl << "ERROR in IFStreamAscii::readDouble" << endl
             << "  Could Not Scan Double From Token = " << sd << endl
       << "  On File Line: " << strTotlLinesRead << " ..." << endl;
    throw GeoTessException(os, __FILE__, __LINE__, 9206);
  }
 
  // successful ... return true
 
  return true;
}
 
} // end namespace geotess
 
#endif  // INTERPOLATOR_OBJECT_H