span.h

Go to the documentation of this file.

/*********************************************************************************
** Copyright (c) 2020 MAK Technologies, Inc.
** All rights reserved.
*********************************************************************************/


#pragma once

#include <stdexcept>

#include <vector>

namespace Legion
{
   template <typename DATA_TYPE>
   class Span
   {
   public:
      Span()
         :myCount(0)
         , myData(0)
      {
      }

      Span(const DATA_TYPE* data, int count)
         :myCount(count)
         , myData(data)
      {
      }

      Span(const std::vector<DATA_TYPE>& dataVector)
         :myCount(dataVector.size())
         , myData(dataVector.data())
      {
      }

      ~Span()
      {
      }

      Span(const Span& orig)
      {
         myData = orig.myData;
         myCount = orig.myCount;
      }

      Span& operator=(const Span& orig)
      {
         if (this != &orig)
         {
            myData = orig.myData;
            myCount = orig.myCount;
         }

         return *this;
      }

      inline bool operator==(const Span<DATA_TYPE>& rhs) const
      {
         return myData == rhs.myData && myCount == rhs.myCount;
      }

      inline bool operator!=(const Span<DATA_TYPE>& rhs) const
      {
         return !(*this == rhs);
      }

      inline int size() const { return myCount; }

      inline int sizeInBytes() const { return myCount * sizeof(DATA_TYPE); }
      
      inline const DATA_TYPE* data() const {return myData;}

      const DATA_TYPE& operator[](int index) const
      {
#if _DEBUG
         if (index < 0 || index > myCount)
         {
            throw  std::runtime_error("Index out of range");
         }
#endif

         return myData[index];
      }

      Span slice(int offset)
      {
         return Span(myData + offset, myCount - offset);
      }

      Span slice(int offset, int count)
      {
#if _DEBUG
         if ((offset + count) > myCount)
         {
            throw  std::runtime_error("Subspan out of range");
         }
#endif  

         return Span(myData + offset, count);
      }

      inline std::vector<DATA_TYPE>& assignTo(std::vector<DATA_TYPE>& destination) const
      {
         if (size() > 0)
            destination.assign(data(), data() + size());
         else
            destination.clear();
         return destination;
      }

      inline std::vector<DATA_TYPE>& appendTo(std::vector<DATA_TYPE>& destination) const
      {
         if (size() > 0)
            destination.insert(destination.end(), data(), data() + size());
         return destination;
      }


   protected:
      int myCount;
      const DATA_TYPE* myData;
   };
}