DataEncoder.h++

Go to the documentation of this file.

/* ---------------------------------------------------------------------------
   commonc++ - A C++ Common Class Library
   Copyright (C) 2005-2012  Mark A Lindner

   This file is part of commonc++.

   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License as published by the Free Software Foundation; either
   version 2 of the License, or (at your option) any later version.

   This library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Library General Public License for more details.

   You should have received a copy of the GNU Library General Public
   License along with this library; if not, write to the Free
   Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
   ---------------------------------------------------------------------------
*/

#ifndef __ccxx_DataEncoder_hxx
#define __ccxx_DataEncoder_hxx

#include <commonc++/IOException.h++>

#include <deque>

namespace ccxx {

class DataEncoder; // fwd decl

class COMMONCPP_API DataEncoder
{
  public:

  class COMMONCPP_API Manipulator
  {
    public:

    virtual ~Manipulator() throw() { }

    virtual void apply(DataEncoder &encoder) const throw(IOException) = 0;
  };

  class COMMONCPP_API SetEndianness : public Manipulator
  {
    public:

    SetEndianness(Endianness endianness) throw();

    ~SetEndianness() throw();

    protected:

    void apply(DataEncoder &encoder) const throw(IOException);

    private:

    Endianness _endianness;
  };

  class COMMONCPP_API SetLength : public Manipulator
  {
    public:

    SetLength(size_t length) throw();

    ~SetLength() throw();

    protected:

    void apply(DataEncoder &encoder) const throw(IOException);

    private:

    size_t _length;
  };

  class COMMONCPP_API Skip : public Manipulator
  {
    public:

    Skip(size_t count) throw();

    ~Skip() throw();

    protected:

    void apply(DataEncoder &encoder) const throw(IOException);

    private:

    size_t _count;
  };

  class COMMONCPP_API Align : public Manipulator
  {
    public:

    Align(size_t size) throw();

    ~Align() throw();

    protected:

    void apply(DataEncoder &encoder) const throw(IOException);

    private:

    size_t _size;
  };

  class COMMONCPP_API SetLimit : public Manipulator
  {
    public:

    SetLimit(int64_t limit) throw();

    ~SetLimit() throw();

    protected:

    void apply(DataEncoder &encoder) const throw(IOException);

    private:

    int64_t _limit;
  };

  class COMMONCPP_API SetStringPadding : public Manipulator
  {
    public:

    SetStringPadding(bool stringPadding) throw();

    ~SetStringPadding() throw();

    protected:

    void apply(DataEncoder &encoder) const throw(IOException);

    private:

    bool _stringPadding;
  };

  virtual void reset() throw(IOException);

  void pushContext();

  void popContext();

  bool isTopContext() const throw();

  uint_t getContextDepth() const throw();

  void setEndianness(Endianness endianness) throw();

  Endianness getEndianness() const throw();

  void setLength(size_t length) throw();

  size_t getLength() const throw();

  void setLimit(int64_t limit) throw(IOException);

  int64_t getLimit() const throw();

  void setStringPadding(bool stringPadding) throw();

  bool getStringPadding() const throw();

  int64_t getOffset() const throw();

  virtual void setOffset(int64_t offset) throw(IOException) = 0;

  int64_t getCumulativeOffset() const throw();

  int64_t getRemaining() const throw();

  void align(size_t size) throw(IOException);

  virtual void skip(size_t count) throw(IOException) = 0;

  virtual ~DataEncoder() throw();

  protected:

  DataEncoder() throw();

  bool isSameEndianness() const throw();

  struct Context
  {
    Context();

    void reset();

    void bumpOffset(size_t delta);

    Endianness endianness;
    size_t length;
    int64_t limit;
    int64_t parentLimit;
    int64_t offset;
    int64_t maxOffset;
    bool stringPadding;
  };

  Context &currentContext();

  const Context &currentContext() const;

  void checkRemaining(const Context &ctx, size_t count) const
    throw(IOException);

  class ContextStack; // fwd decl

  ContextStack *_contexts;
  int64_t _maxOffset;
  private:

  CCXX_COPY_DECLS(DataEncoder);
};

}; // namespace ccxx

#endif // __ccxx_DataEncoder_hxx

/* end of header file */