Buffer.hpp

Go to the documentation of this file.

//
// Copyright (c) 2010-2024 60East Technologies Inc., All Rights Reserved.
//
// This computer software is owned by 60East Technologies Inc. and is
// protected by U.S. copyright laws and other laws and by international
// treaties.  This computer software is furnished by 60East Technologies
// Inc. pursuant to a written license agreement and may be used, copied,
// transmitted, and stored only in accordance with the terms of such
// license agreement and with the inclusion of the above copyright notice.
// This computer software or any other copies thereof may not be provided
// or otherwise made available to any other person.
//
// U.S. Government Restricted Rights.  This computer software: (a) was
// developed at private expense and is in all respects the proprietary
// information of 60East Technologies Inc.; (b) was not developed with
// government funds; (c) is a trade secret of 60East Technologies Inc.
// for all purposes of the Freedom of Information Act; and (d) is a
// commercial item and thus, pursuant to Section 12.212 of the Federal
// Acquisition Regulations (FAR) and DFAR Supplement Section 227.7202,
// Government's use, duplication or disclosure of the computer software
// is subject to the restrictions set forth by 60East Technologies Inc..
//

#ifndef _BUFFER_H_
#define _BUFFER_H_

#include <amps/ampsplusplus.hpp>


namespace AMPS
{

  class Buffer
  {
  public:
    struct ByteArray
    {
      char*  _data;
      size_t _len;
      // If true, the _data buffer is owned and must be deleted
      bool   _owned;

      ByteArray() : _data(0), _len(0), _owned(false) {}

      ByteArray(char* data_, size_t len_, bool owned_)
        : _data(data_), _len(len_), _owned(owned_) {}

      ByteArray(const ByteArray& rhs_) : _data(rhs_._data), _len(rhs_._len)
        , _owned(rhs_._owned)
      {
        const_cast<ByteArray&>(rhs_)._owned = false;
      }

      ~ByteArray()
      {
        if (_owned)
        {
          delete[] _data;
        }
      }

      ByteArray& operator=(const ByteArray& rhs_)
      {
        _data = rhs_._data;
        _len = rhs_._len;
        _owned = rhs_._owned;
        const_cast<ByteArray&>(rhs_)._owned = false;
        return *this;
      }
    };

    virtual ~Buffer() {}

    virtual size_t        getSize() const = 0;

    virtual void          setSize(size_t newSize_) = 0;

    virtual size_t        getPosition() const = 0;

    virtual void          setPosition(size_t position_) = 0;

    virtual void          putByte(char byte_) = 0;

    virtual char          getByte() = 0;

    virtual void          putUint32(amps_uint32_t i_) = 0;

    virtual amps_uint32_t getUint32() = 0;

    virtual void          putInt32(amps_int32_t i_) = 0;

    virtual amps_int32_t  getInt32() = 0;

    virtual void          putSizet(size_t s_) = 0;

    virtual size_t        getSizet() = 0;

    virtual void          putUint64(amps_uint64_t ui_) = 0;

    virtual amps_uint64_t getUint64() = 0;

    virtual void          putInt64(amps_int64_t i_) = 0;

    virtual amps_int64_t  getInt64() = 0;

    virtual void          putBytes(const char* data_, size_t dataLength_) = 0;

    virtual void          putBytes(const ByteArray& bytes_) = 0;

    virtual ByteArray  getBytes(size_t numBytes_) = 0;

    virtual void copyBytes(char* buffer_, size_t numBytes_) = 0;

    virtual void       zero(size_t offset_, size_t length_) = 0;

    virtual void        copyBytes(size_t destination_, size_t source_,
                                  size_t number_) = 0;
  };

} // end namespace AMPS

#endif //_BUFFER_H_