MWAWInputStream.hxx

Go to the documentation of this file.

/* -*- Mode: C++; c-default-style: "k&r"; indent-tabs-mode: nil; tab-width: 2; c-basic-offset: 2 -*- */

/* libmwaw
* Version: MPL 2.0 / LGPLv2+
*
* The contents of this file are subject to the Mozilla Public License Version
* 2.0 (the "License"); you may not use this file except in compliance with
* the License or as specified alternatively below. You may obtain a copy of
* the License at http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* Major Contributor(s):
* Copyright (C) 2002 William Lachance (wrlach@gmail.com)
* Copyright (C) 2002,2004 Marc Maurer (uwog@uwog.net)
* Copyright (C) 2004-2006 Fridrich Strba (fridrich.strba@bluewin.ch)
* Copyright (C) 2006, 2007 Andrew Ziem
* Copyright (C) 2011, 2012 Alonso Laurent (alonso@loria.fr)
*
*
* All Rights Reserved.
*
* For minor contributions see the git repository.
*
* Alternatively, the contents of this file may be used under the terms of
* the GNU Lesser General Public License Version 2 or later (the "LGPLv2+"),
* in which case the provisions of the LGPLv2+ are applicable
* instead of those above.
*/

#ifndef MWAW_INPUT_STREAM_H
#define MWAW_INPUT_STREAM_H

#include <string>
#include <vector>

#include <librevenge/librevenge.h>
#include <librevenge-stream/librevenge-stream.h>
#include "libmwaw_internal.hxx"

class MWAWInputStream
{
public:
  MWAWInputStream(shared_ptr<librevenge::RVNGInputStream> input, bool inverted);

  MWAWInputStream(librevenge::RVNGInputStream *input, bool inverted, bool checkCompression=false);
  ~MWAWInputStream();

  shared_ptr<librevenge::RVNGInputStream> input()
  {
    return m_stream;
  }
  static shared_ptr<MWAWInputStream> get(librevenge::RVNGBinaryData const &data, bool inverted);

  bool readInverted() const
  {
    return m_inverseRead;
  }
  void setReadInverted(bool newVal)
  {
    m_inverseRead = newVal;
  }
  //
  // Position: access
  //

  int seek(long offset, librevenge::RVNG_SEEK_TYPE seekType);
  long tell();
  long size() const
  {
    return m_streamSize;
  }
  bool checkPosition(long pos) const
  {
    if (pos < 0) return false;
    if (m_readLimit > 0 && pos > m_readLimit) return false;
    return pos<=m_streamSize;
  }
  bool isEnd();

  void pushLimit(long newLimit)
  {
    m_prevLimits.push_back(m_readLimit);
    m_readLimit = newLimit > m_streamSize ? m_streamSize : newLimit;
  }
  void popLimit()
  {
    if (m_prevLimits.size()) {
      m_readLimit = m_prevLimits.back();
      m_prevLimits.pop_back();
    }
    else m_readLimit = -1;
  }

  //
  // get data
  //

  unsigned long readULong(int num)
  {
    return readULong(m_stream.get(), num, 0, m_inverseRead);
  }
  long readLong(int num);
  bool readDouble8(double &res, bool &isNotANumber);
  bool readDoubleReverted8(double &res, bool &isNotANumber);
  bool readDouble10(double &res, bool &isNotANumber);

  const uint8_t *read(size_t numBytes, unsigned long &numBytesRead);
  static unsigned long readULong(librevenge::RVNGInputStream *stream, int num, unsigned long a, bool inverseRead);

  bool readDataBlock(long size, librevenge::RVNGBinaryData &data);
  bool readEndDataBlock(librevenge::RVNGBinaryData &data);

  //
  // OLE/Zip access
  //

  bool isStructured();
  unsigned subStreamCount();
  std::string subStreamName(unsigned id);

  shared_ptr<MWAWInputStream> getSubStreamByName(std::string const &name);
  shared_ptr<MWAWInputStream> getSubStreamById(unsigned id);

  //
  // Finder Info access
  //
  bool getFinderInfo(std::string &type, std::string &creator) const
  {
    if (!m_fInfoType.length() || !m_fInfoCreator.length()) {
      type = creator = "";
      return false;
    }
    type = m_fInfoType;
    creator = m_fInfoCreator;
    return true;
  }

  //
  // Resource Fork access
  //

  bool hasDataFork() const
  {
    return bool(m_stream);
  }
  bool hasResourceFork() const
  {
    return bool(m_resourceFork);
  }
  shared_ptr<MWAWInputStream> getResourceForkStream()
  {
    return m_resourceFork;
  }


protected:
  void updateStreamSize();
  static uint8_t readU8(librevenge::RVNGInputStream *stream);

  bool unBinHex();
  bool unzipStream();
  bool unMacMIME();
  bool unMacMIME(MWAWInputStream *input,
                 shared_ptr<librevenge::RVNGInputStream> &dataInput,
                 shared_ptr<librevenge::RVNGInputStream> &rsrcInput) const;

private:
  MWAWInputStream(MWAWInputStream const &orig);
  MWAWInputStream &operator=(MWAWInputStream const &orig);

protected:
  shared_ptr<librevenge::RVNGInputStream> m_stream;
  long m_streamSize;

  bool m_inverseRead;

  long m_readLimit;
  std::vector<long> m_prevLimits;

  mutable std::string m_fInfoType;
  mutable std::string m_fInfoCreator;
  shared_ptr<MWAWInputStream> m_resourceFork;
};

#endif
// vim: set filetype=cpp tabstop=2 shiftwidth=2 cindent autoindent smartindent noexpandtab: