---

InputFile.cpp

Go to the documentation of this file.

//
// Copyright (C) 2000
// Ralf Westram
// Time-stamp: <Fri May/03/2002 18:56 MET Coder@ReallySoft.de>
//
// Permission to use, copy, modify, distribute and sell this software
// and its documentation for any purpose is hereby granted without fee,
// provided that the above copyright notice appear in all copies and
// that both that copyright notice and this permission notice appear
// in supporting documentation.  Ralf Westram makes no
// representations about the suitability of this software for any
// purpose.  It is provided "as is" without express or implied warranty.
//
// This code is part of my library.
// You may find a more recent version at http://www.reallysoft.de/
//

#include "InputFile.h"

using namespace std;
using namespace rs;
using namespace rs::err;
using namespace rs::file;

// start of implementation of class InputFile:

//  -------------------------------------------------------------------
//      InputFile::InputFile(const string& filename_, int bufsize_)
//  -------------------------------------------------------------------
InputFile::InputFile(const string& filename_, int bufsize_)
    : filename(filename_),
      current_line(0),
      in(0),
      bufsize(bufsize_),
      offset(0),
      filled(0),
      buffer(0),
      end_of_file_seen(false),
      ignore_empty(false),
      do_auto_break(0)
{
    in = fopen(filename.c_str(), "rt");
    //    cerr << "filename='" << filename << "'" << endl;
    if (!in) throw IOError(filename);

    buffer = new char[bufsize];
    fillBuffer();
}

//  -------------------------------------------
//      InputFile::InputFile(int bufsize_)
//  -------------------------------------------
InputFile::InputFile(int bufsize_)
    : filename("STDIN"),
      current_line(0),
      in(0),
      bufsize(bufsize_),
      offset(0),
      filled(0),
      buffer(0),
      end_of_file_seen(false),
      ignore_empty(false),
      do_auto_break(0)
{
    in = stdin;
    buffer = new char[bufsize];
    fillBuffer();
}

//  ---------------------------------------------------------------------------------------------------
//      void InputFile::autoLinebreak(int max_line_length, const string& toBreak, int toBreakAtPos)
//  ---------------------------------------------------------------------------------------------------
void InputFile::autoLinebreak(int max_line_length, const string& toBreak, int toBreakAtPos)
{
    do_auto_break = max_line_length;
    breakAt       = toBreak;
    breakAtPos    = toBreakAtPos;
}

//  ------------------------------------------------
//      bool InputFile::getLine(string& result)
//  ------------------------------------------------
bool InputFile::getLine(string& result) {
    bool got_line = false;
    result        = "";
    do {
//         cout << "result[1]='" << result << "'\n";

        while (offset>=filled) { // alles ausgelesen
            if (end_of_file_seen) {
                if (result.length()) return true;
                return false;
            }
            fillBuffer();
        }

        assert(offset<filled);
        size_t  rest     = filled-offset;
        char   *line_end = (char*)memchr(buffer+offset, '\n', rest);

        if (line_end) {
            int line_length             = (line_end-buffer)-offset; // length of line excl. \n
            assert(line_length>=0);
            assert(size_t(line_length) <= rest);
            result                      = result+string(buffer+offset, line_length);
            offset                     += line_length+1;
            got_line                    = true;
            current_line++;
        }
        else {
            // line is only partially in buffer

            result = result+string(buffer+offset, rest);
//             cout << "result[2]='" << result << "'\n";
            if (do_auto_break && result.length() > size_t(do_auto_break)) { // maybe line should be broken
                size_t best_offset = string::npos;
                size_t curr_offset = 0;

                while (curr_offset < size_t(do_auto_break)) {
                    size_t found = result.find(breakAt, curr_offset);
                    if (found == string::npos) break;

                    if ((found+breakAtPos) <= size_t(do_auto_break)) best_offset = found+breakAtPos;
                    curr_offset             = found+1;
                }

                if (best_offset != string::npos) { // found a position where line will be broken
                    rest   -= best_offset;
                    assert(filled >= rest);
                    offset  = filled-rest;
                    result.erase(best_offset);
//                     cout << "result[3]='" << result << "'\n";
                    got_line = true;
                }
            }
            if (!got_line) { // did not break -> append next line
                rest   = 0;
                offset = filled;
            }
        }

        if (got_line && ignore_empty && result.empty()) got_line = false;
    }
    while (!got_line);
//     cout << "result[4]='" << result << "'\n";
    return true;
}

// -end- of implementation of class InputFile.


// //  ------------------------------------------------
// //      bool InputFile::getLine(string& result)
// //  ------------------------------------------------
// bool InputFile::getLine(string& result) {
//     if (end_of_file_seen) return false;
//     if (in.eof()) {
//         end_of_file_seen = true;
//         return false;
//     }
//     if (!in.good()) {
//         throw IOError(filename);
//     }
//     char buf[bufsize];

//     if (!in.getline(buf, bufsize)) {
//         end_of_file_seen = true;
//         return false;
//     }

//     ++current_line;
//     result = string(buf);
//     return true;
// }

---

Contact me in case of errors or questions. This documentation is powered by .

(C) 2000-2002