root/trunk/whisperlib/common/io/input_stream.h

// Copyright (c) 2009, Whispersoft s.r.l.
// 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 Whispersoft s.r.l. 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
// OWNER 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.
//
// Author: Cosmin Tudorache

#ifndef __COMMON_IO_INPUT_STREAM_H__
#define __COMMON_IO_INPUT_STREAM_H__

#include <string>

#include <whisperlib/common/base/types.h>
#include <whisperlib/common/base/system.h>
#include <whisperlib/common/base/log.h>
#include <whisperlib/common/base/strutil.h>

#include <whisperlib/common/io/stream_base.h>
#include <whisperlib/common/io/iomarker.h>
#include <whisperlib/common/io/seeker.h>

namespace io {

class InputStream : public StreamBase {
 public:
  InputStream() : StreamBase() {
  }
  InputStream(common::ByteOrder byte_order,
              IoMarker* marker, Seeker* seeker)
    : StreamBase(byte_order, marker, seeker) {
  }
  virtual ~InputStream() {
  }

  // Reads "len" bytes of data into the given "buffer".
  // Returns the number of bytes read. Can be less than "len" if less bytes
  // are available.
  virtual int32 Read(void* buffer, int32 len) = 0;

  // Same as read, but w/ strings
  // If len == -1 read to the end of input, else read len bytes. Returns
  // anyway the number of read bytes
  virtual int32 ReadString(string* s, int32 len = -1) {
    if ( len == -1 )
      len = Readable();
    string tmp;
    tmp.reserve(len);
    const int32 cb = Read(&tmp[0], len);
    s->assign(tmp.c_str(), cb);
    return cb;
  }

  // 'Peeks' len bytes from the stream at the current position. On return the
  // read pointer is left unchanged.
  // Returns the number of bytes read or 0 in not available or operation not
  // supported.
  virtual int32 Peek(void* buffer, int32 len) = 0;

  // Passes over "len" bytes. (Advances the read head by the "len" number of
  // bytes).
  // Returns the number of bytes skipped. Can be less than "len" if less
  // bytes are available.
  virtual int64 Skip(int64 len) = 0;

  // Returns how many bytes are readable in the stream until EOS
  virtual int64 Readable() const = 0;

  // Returns (Readable() == 0) (Usually much faster)
  virtual bool IsEos() const = 0;

  // Sets the read marker in the current stream possition.
  virtual void MarkerSet() = 0;

  // Restores the read position of the associated stream to the position
  // previously marked by set.
  virtual void MarkerRestore() = 0;

  // Removes the last read mark for the underlying stream
  virtual void MarkerClear() = 0;

  // !! NOTE !!
  //  -- This is amazingly expensive !! Use it only for debugging --
  virtual string ToString() const {
#ifdef _DEBUG
    InputStream& in = const_cast<InputStream&>(*this);
    const int64 size = in.Readable();
    in.MarkerSet();
    string buffer;
    in.ReadString(&buffer);
    in.MarkerRestore();
    DCHECK_EQ(in.Readable(), size);

    return (strutil::StringPrintf("InputStream [#%lld bytes]:\n",
                                  static_cast<long long int>(size)) +
            strutil::PrintableDataBuffer(buffer.data(), buffer.size()));
#else
    return (strutil::StringPrintf("InputStream [#%lld bytes]:\n",
                                  static_cast<long long int>(Readable())));
#endif
  }
  virtual string PeekString() const {
    string s;
    InputStream& in = const_cast<InputStream&>(*this);
    const int64 size = in.Readable();
    in.MarkerSet();
    in.ReadString(&s);
    in.MarkerRestore();
    CHECK_EQ(in.Readable(), size);
    return s;
  }
 private:
  DISALLOW_EVIL_CONSTRUCTORS(InputStream);
};
inline std::ostream& operator<<(std::ostream& os,
                                const InputStream& in) {
  return os << in.ToString();
}
}
#endif  // __COMMON_IO_INPUT_STREAM_H__