byte_array.h

Go to the documentation of this file.

 
#ifndef BYTE_ARRAY_H
#define BYTE_ARRAY_H
 
#include <argos3/core/utility/datatypes/datatypes.h>
#include <argos3/core/utility/configuration/argos_exception.h>
#include <vector>
#include <iterator>
#include <unistd.h>
 
namespace argos {
 
   class CByteArray {
 
   public:
 
      CByteArray() {}
 
      CByteArray(const CByteArray& c_byte_array) :
         m_vecBuffer(c_byte_array.m_vecBuffer) {}
 
      CByteArray(const UInt8* pun_buffer,
                 size_t un_size);
 
      CByteArray(size_t un_size,
                 UInt8 un_value = 0);
 
      inline size_t Size() const {
         return m_vecBuffer.size();
      }
 
      inline void Resize(size_t un_size,
                         UInt8 un_value = 0) {
         m_vecBuffer.resize(un_size, un_value);
      }
 
      inline void Swap(CByteArray& c_other) {
         m_vecBuffer.swap(c_other.m_vecBuffer);
      }
 
      inline bool Empty() const {
         return m_vecBuffer.empty();
      }
 
      inline const UInt8* ToCArray() const {
         return !Empty() ? &m_vecBuffer[0] : NULL;
      }
 
      inline UInt8* ToCArray() {
         return !Empty() ? &m_vecBuffer[0] : NULL;
      }
 
      inline void Clear() {
         m_vecBuffer.clear();
      }
 
      void Zero();
 
      CByteArray& operator=(const CByteArray& c_byte_array);
 
      inline UInt8& operator[](size_t un_index) {
         if(un_index >= Size()) THROW_ARGOSEXCEPTION("CByteArray: index out of bounds [index = " << un_index << ", size=" << Size() << "]");
         return m_vecBuffer.at(un_index);
      }
 
      inline UInt8 operator[](size_t un_index) const {
         if(un_index >= Size()) THROW_ARGOSEXCEPTION("CByteArray: index out of bounds [index = " << un_index << ", size=" << Size() << "]");
         return m_vecBuffer.at(un_index);
      }
 
      bool operator==(const CByteArray& c_byte_array) const;
 
      CByteArray& AddBuffer(const UInt8* pun_buffer,
                            size_t un_size);
 
      CByteArray& FetchBuffer(UInt8* pun_buffer,
                              size_t un_size);
 
      template<typename T> T PopFront() {
         T tRetVal;
         *this >> tRetVal;
         return tRetVal;
      }
 
      CByteArray* operator()(size_t un_start,
                             ssize_t un_end = -1);
 
      CByteArray& operator<<(UInt8 un_value);
 
      CByteArray& operator>>(UInt8& un_value);
 
      CByteArray& operator<<(SInt8 n_value);
 
      CByteArray& operator>>(SInt8& n_value);
 
      CByteArray& operator<<(UInt16 un_value);
 
      CByteArray& operator>>(UInt16& un_value);
 
      CByteArray& operator<<(SInt16 n_value);
 
      CByteArray& operator>>(SInt16& n_value);
 
      CByteArray& operator<<(UInt32 un_value);
 
      CByteArray& operator>>(UInt32& un_value);
 
      CByteArray& operator<<(SInt32 n_value);
 
      CByteArray& operator>>(SInt32& n_value);
 
      CByteArray& operator<<(UInt64 un_value);
 
      CByteArray& operator>>(UInt64& un_value);
 
      CByteArray& operator<<(SInt64 n_value);
 
      CByteArray& operator>>(SInt64& n_value);
 
      CByteArray& operator<<(unsigned long int un_value);
 
      CByteArray& operator>>(unsigned long int& un_value);
 
      CByteArray& operator<<(signed long int n_value);
 
      CByteArray& operator>>(signed long int& n_value);
 
      CByteArray& operator<<(double f_value);
 
      CByteArray& operator>>(double& f_value);
 
      CByteArray& operator<<(float f_value);
 
      CByteArray& operator>>(float& f_value);
 
      CByteArray& operator<<(const std::string& str_value);
 
      CByteArray& operator>>(std::string& str_value);
 
      friend std::ostream& operator<<(std::ostream& c_os, const CByteArray& c_byte_array);
 
   private:
 
      std::vector<UInt8> m_vecBuffer;
 
   };
 
}
 
#endif