DinoLineBuffer.h

Go to the documentation of this file.

/*
 * $Revision: 2299 $
 * 
 * last checkin:
 *   $Author: gutwenger $ 
 *   $Date: 2012-05-07 15:57:08 +0200 (Mon, 07 May 2012) $ 
 ***************************************************************/
 
#ifdef _MSC_VER
#pragma once
#endif

#ifndef OGDF_DINO_LINE_BUFFER_H
#define OGDF_DINO_LINE_BUFFER_H

#include <ogdf/basic/basic.h>


namespace ogdf {

    //---------------------------------------------------------
    // D i n o L i n e B u f f e r P o s i t i o n
    //---------------------------------------------------------
    class OGDF_EXPORT DinoLineBufferPosition {
        
    private:

        int m_lineNumber;

        int m_lineUpdateCount;

        int m_linePosition;

    public:

        DinoLineBufferPosition() : 
          m_lineNumber(0), 
          m_lineUpdateCount(0), 
          m_linePosition(0)
        {}

        DinoLineBufferPosition(int lineNumber, 
                               int lineUpdateCount, 
                               int linePosition);

        DinoLineBufferPosition(const DinoLineBufferPosition &position);

        inline int getLineNumber() const {
            return m_lineNumber;
        }

        inline int getLineUpdateCount() const {
            return m_lineUpdateCount;
        }

        inline int getLinePosition() const {
            return m_linePosition;
        }

        void set(int lineNumber, int lineUpdateCount, int linePosition);

        void incrementPosition();

        bool operator!=(const DinoLineBufferPosition &position) const;

        const DinoLineBufferPosition &operator=(const DinoLineBufferPosition &position);

    }; // DinoLineBufferPosition

    //---------------------------------------------------------
    // D i n o L i n e B u f f e r 
    //---------------------------------------------------------
    class OGDF_EXPORT DinoLineBuffer {

    public:

        // Maximal length of a string handled by extractString()
        const static int c_maxStringLength;

        // Maximal length of one line 
        const static int c_maxLineLength;

        // Maximal number of lines
        const static int c_maxNoOfLines;

    private:

        // Handle to the input file
        istream *m_pIs;

        // Contains for each line of the line buffer its update count
        // Range is [0 .. c_maxNoOfLines]
        int *m_lineUpdateCountArray;

        // Pointer to the line buffer
        char *m_pLinBuf;

        // The current position in m_pLinBuf
        DinoLineBufferPosition m_currentPosition;

        // The line which has been read from the file most recently; 
        // this does not have to be equal to m_currentPosition.m_lineNumber
        // because of the lookahead facilities.
        // Range is [0 .. c_maxNoOfLines - 1]
        int m_numberOfMostRecentlyReadLine;

        // Contains the current line number of the input file; 
        int m_inputFileLineCounter;

    public:

        // construction
        DinoLineBuffer(const char *fileName);

        // destruction
        ~DinoLineBuffer();

        // Returns the current position (as a copy)
        DinoLineBufferPosition getCurrentPosition() const{
            return m_currentPosition;
        }

        // Returns the character which is currently pointed to
        inline char getCurrentCharacter() const {
            return m_pLinBuf[(m_currentPosition.getLineNumber() * DinoLineBuffer::c_maxLineLength) + 
                                 m_currentPosition.getLinePosition()];
        }

        // Returns line number of the most recently read line of the input file
        inline int getInputFileLineCounter() const {
            return m_inputFileLineCounter;
        }

        // Moves to the next position;
        // reading of new lines and handling of eof are done internally.
        // If end of file is reached the position will stuck to EOF character.
        // The current character after moving is returned
        char moveToNextCharacter();

        // Sets the current position to new positon.
        // Takes care if the given newPosition is valid.
        // Returns false if given position is invalid
        bool setCurrentPosition(const DinoLineBufferPosition &newPosition);

        // Moves to the next character until the currentCharacter is
        // no whitespace.
        void skipWhitespace();

        // Copys the characters which have been extracted from the 
        // line buffer starting from position startPosition (including it) 
        // to endPosition (excluding it) to targetString (terminated by '\0').
        // The length of strings is limited to c_maxStringLength
        //
        // Returns false if the startPosition is not valid, i.e. the string
        // is too long; targetString will contain the message "String too long!"
        bool extractString(const DinoLineBufferPosition &startPostion,
                           const DinoLineBufferPosition &endPosition,
                           char *targetString);

    private:

        // Returns a pointer to the character which is currently pointed to
        inline char *getCurrentCharacterPointer() {
            return &m_pLinBuf[(m_currentPosition.getLineNumber() * DinoLineBuffer::c_maxLineLength) + 
                                   m_currentPosition.getLinePosition()];
        }

        // Sets the given character to the current position
        inline void setCurrentCharacter(char c) {
            m_pLinBuf[(m_currentPosition.getLineNumber() * DinoLineBuffer::c_maxLineLength) + 
                           m_currentPosition.getLinePosition()] = c;
        }

        // Checks wether the given position is valid
        bool isValidPosition(const DinoLineBufferPosition &position) const;

    }; // class DinoLineBuffer

} // end namespace ogdf

#endif