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