inputStream.h

Go to the documentation of this file.

#ifndef _DLR_COMMON_INPUTSTREAM_H_
#define _DLR_COMMON_INPUTSTREAM_H_

#include <cstring>
#include <iostream>

namespace dlr {

  namespace common {
    
    class InputStream
    {
    public:
      /* ============ Typedefs "inherited" from std::istream ============ */
      typedef std::istream::char_type char_type;


      /* ================== New typedefs and constants ================== */
    
      typedef unsigned int FormatFlag;

    
      static const FormatFlag NO_FLAG         = 0x00;

    
      static const FormatFlag SKIP_WHITESPACE = 0x01;

    
      static const FormatFlag SLOPPY_EXPECT   = 0x02;

    
      InputStream(std::istream& inputStream, FormatFlag flags=NO_FLAG)
        : m_istream(inputStream),
          m_skipWhiteSpace((flags & SKIP_WHITESPACE) != 0),
          m_sloppyExpect((flags & SLOPPY_EXPECT) != 0) {}


      ~InputStream() {}

      /* =================== Conversion operators =================== */

      operator void*() const {
        return m_istream;
      }


      operator std::istream&() const {
        return m_istream;
      }

      /* ============ Operators "inherited" from std::istream ============ */

      template <class Type>
      InputStream&
      operator>>(Type& typeInstance) {
        m_istream >> typeInstance;
        return *this;
      }


      /* ======== Member functions "inherited" from std::istream ======== */

      bool
      bad() {
        return m_istream.bad();
      }

    
      void
      clear(std::istream::iostate state=std::istream::goodbit) {
        m_istream.clear(state);
      }


      bool
      eof() {
        return m_istream.eof();
      }

    
      bool
      fail() {
        return m_istream.fail();
      }

    
      std::istream::int_type
      get() {
        return m_istream.get();
      }


      InputStream
      getline(char_type* inputBuffer, std::streamsize numberOfCharacters) {
        return m_istream.getline(inputBuffer, numberOfCharacters);
      }
    
    
      std::istream::int_type
      peek() {
        return m_istream.peek();
      }

    
      /* =================== New member functions =================== */

      InputStream&
      expect(std::istream::char_type inputChar) {
        std::istream::char_type readChar = 0;
        *this >> readChar;
        if(readChar != inputChar) {
          this->clear(std::ios_base::failbit);
        }
        return *this;
      }


      InputStream&
      expect(const std::string& inputString) {
        return this->expect(inputString.c_str(), inputString.size());
      }


      InputStream&
      expect(const char* inputCString, size_t stringSize=0) {
        // We need an area into which to read.
        std::istream::char_type inputBuffer[s_chunkSize + 1];

        // Remove leading white space, if required.
        if(m_skipWhiteSpace) {
          this->skipWhiteSpace();
        }
      
        // inputString might be very long, so we keep count of how much
        // we've read.
        size_t readCount = 0;

        // If the caller hasn't specified how long the string is, we
        // find out using strlen().
        if(stringSize == 0) {
          stringSize = strlen(inputCString);        
        }
      
        while(readCount < stringSize) {
          // Figure out how much to read.
          size_t thisChunkCount = stringSize - readCount;

          // But be sure not to overflow the buffer.
          if(thisChunkCount > s_chunkSize) {
            thisChunkCount = s_chunkSize;
          }

          // Read the appropriate number of characters.
          m_istream.read(inputBuffer,
                         static_cast<std::streamsize>(thisChunkCount));
          
          // Quit if we weren't able to read enough bytes.
          if(static_cast<size_t>(m_istream.gcount()) != thisChunkCount) {
            this->clear(std::ios_base::failbit);
            break;
          }
          
          // Now evaluate what we've read.
          bool matchFlag = true;
          if(!m_sloppyExpect) {
            // We use memcmp() instead of strncmp() because the caller
            // might conceivably expect a string with a '\0' in the middle.
            matchFlag = (
              std::memcmp(reinterpret_cast<const void*>(inputCString
                                                        + readCount),
                          reinterpret_cast<const void*>(inputBuffer),
                          thisChunkCount * sizeof(char)) == 0);
          }

          // Quit if it wasn't what we expected.
          if(!matchFlag) {
            this->clear(std::ios_base::failbit);
            break;
          }
        
          // Increment our count of how many characters read.
          readCount += thisChunkCount;
        }
        return *this;
      }
    

      void
      skipWhiteSpace() {
        std::istream::char_type inputChar;
        m_istream >> inputChar;
        m_istream.putback(inputChar);
      }

    
    private:
      static const size_t s_chunkSize = 1024;
      std::istream& m_istream;
      bool m_skipWhiteSpace;
      bool m_sloppyExpect;
    };

  } // namespace common
  
} // namespace dlr


/* ======= Declarations to maintain compatibility with legacy code. ======= */

namespace dlr {

  using common::InputStream;
  
} // namespace dlr

#endif // #ifndef _DLR_COMMON_INPUTSTREAM_H_