Buffer.hpp

Go to the documentation of this file.

//
// Copyright (c) 2010-2021 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 <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_