DataEncoder.h++

Go to the documentation of this file.

/* ---------------------------------------------------------------------------
   commonc++ - A C++ Common Class Library
   Copyright (C) 2005-2014  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 ScopedContext
  {
    public:

    ScopedContext(DataEncoder& encoder)
      : _encoder(encoder)
    { _encoder.pushContext(); }

    ~ScopedContext()
    { _encoder.popContext(); }

    private:

    DataEncoder& _encoder;

    CCXX_COPY_DECLS(ScopedContext);
  };

  class COMMONCPP_API Manipulator
  {
   public:

    virtual ~Manipulator() { }

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

  class COMMONCPP_API SetEndianness : public Manipulator
  {
   public:

    SetEndianness(Endianness endianness);

    ~SetEndianness();

   protected:

    void apply(DataEncoder& encoder) const;

   private:

    Endianness _endianness;
  };

  class COMMONCPP_API SetLength : public Manipulator
  {
   public:

    SetLength(size_t length);

    ~SetLength();

   protected:

    void apply(DataEncoder& encoder) const;

   private:

    size_t _length;
  };

  class COMMONCPP_API Skip : public Manipulator
  {
   public:

    Skip(size_t count);

    ~Skip();

   protected:

    void apply(DataEncoder& encoder) const;

   private:

    size_t _count;
  };

  class COMMONCPP_API Align : public Manipulator
  {
   public:

    Align(size_t size);

    ~Align();

   protected:

    void apply(DataEncoder& encoder) const;

   private:

    size_t _size;
  };

  class COMMONCPP_API SetLimit : public Manipulator
  {
   public:

    SetLimit(int64_t limit);

    ~SetLimit();

   protected:

    void apply(DataEncoder& encoder) const;

   private:

    int64_t _limit;
  };

  virtual void reset();

  void pushContext();

  void popContext();

  bool isTopContext() const;

  uint_t getContextDepth() const;

  void setEndianness(Endianness endianness);

  Endianness getEndianness() const;

  void setLength(size_t length);

  size_t getLength() const;

  void setLimit(int64_t limit);

  int64_t getLimit() const;

  int64_t getOffset() const;

  virtual void setOffset(int64_t offset) = 0;

  int64_t getCumulativeOffset() const;

  int64_t getRemaining() const;

  void align(size_t size);

  virtual void skip(size_t count) = 0;

  virtual ~DataEncoder();

 protected:

  DataEncoder();

  bool isSameEndianness() const;

  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;
  };

  Context& currentContext();

  const Context& currentContext() const;

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

  class ContextStack; // fwd decl

  ContextStack* _contexts;
  int64_t _maxOffset;
 private:

  CCXX_COPY_DECLS(DataEncoder);
};

} // namespace ccxx

#endif // __ccxx_DataEncoder_hxx