Array.h

Go to the documentation of this file.

/*
Copyright 2007-2025. Algoryx Simulation AB.
 
All AGX source code, intellectual property, documentation, sample code,
tutorials, scene files and technical white papers, are copyrighted, proprietary
and confidential material of Algoryx Simulation AB. You may not download, read,
store, distribute, publish, copy or otherwise disseminate, use or expose this
material unless having a written signed agreement with Algoryx Simulation AB, or having been
advised so by Algoryx Simulation AB for a time limited evaluation, or having purchased a
valid commercial license from Algoryx Simulation AB.
 
Algoryx Simulation AB disclaims all responsibilities for loss or damage caused
from using this software, unless otherwise stated in written agreements with
Algoryx Simulation AB.
*/
 
#ifndef AGXDATA_ARRAY_H
#define AGXDATA_ARRAY_H
 
#include <agxData/Data.h>
#include <agx/GlobalResult.h>
#include <agx/Vector.h>
 
#ifdef _MSC_VER
# pragma warning(push)
# pragma warning( disable : 4251 ) // class X needs to have dll-interface to be used by clients of class Y
#endif
 
namespace agxData
{
 
  class AGXCORE_EXPORT AbstractArray : public Data
  {
    public:
 
      AbstractArray();
 
      AbstractArray(agxData::Buffer* buffer);
 
      AbstractArray(agxData::Buffer* buffer, agx::IndexRange32 range);
 
      AbstractArray(const agxData::AbstractArray& other, agx::IndexRange32 localRange);
 
      size_t size() const;
 
      bool empty() const;
 
      agx::IndexRange32& range();
      const agx::IndexRange32& range() const;
 
      const agxData::Buffer* buffer() const;
      agxData::Buffer* buffer();
 
      void init(agxData::Buffer* buffer, agx::IndexRange32 range);
 
      void init(agxData::Buffer* buffer);
 
      void init();
 
      void setRange(size_t startIndex, size_t endIndex);
 
      void setRange(agx::IndexRange32 range);
 
      agxData::Format* getFormat();
      const agxData::Format* getFormat() const;
 
      void sync();
 
      bool isValid() const;
 
      void _setBuffer(agxData::Buffer *buffer);
 
    protected:
      friend class SerializedFrame;
      agxData::Buffer* m_buffer;
      agx::IndexRange32 m_range;
  };
 
 
 
  template <typename T>
  class Array : public agxData::AbstractArray
  {
    public:
      typedef T                                  Type;
      typedef T                                  value_type;
      typedef T*                                 pointer;
      typedef const T*                           const_pointer;
      typedef T&                                 reference;
      typedef const T&                           const_reference;
      typedef size_t                             size_type;
      typedef T*                                 iterator;
      typedef const T*                           const_iterator;
      typedef std::random_access_iterator_tag    iterator_category;
      typedef ptrdiff_t                          difference_type;
 
      static const bool IsScalar = false;
 
      static agxData::Array<T> raw(T* buffer, agx::Index size);
      static const agxData::Array<T> raw(const T* buffer, agx::Index size);
 
    public:
      Array();
 
      Array(agxData::Buffer* buffer);
 
      Array(agxData::Buffer* buffer, agx::IndexRange32 range);
 
      Array(const agxData::Array<T>& other, agx::IndexRange32 localRange);
 
      Array(agx::Vector<T>& vec);
      Array(agx::Vector<T>& vec, agx::IndexRange32 range);
      Array(agx::VectorPOD<T>& vec);
      Array(agx::VectorPOD<T>& vec, agx::IndexRange32 range);
 
      T& back();
      const T& back() const;
 
      T& front();
      const T& front() const;
 
      T& operator[] (size_t index);
      const T& operator[] (size_t index) const;
 
      T& at(size_t index);
      const T& at(size_t index) const;
 
      agxData::Array<T> slice(agx::IndexRange32 subRange) const;
 
      agxData::Array<T> operator[] (agx::IndexRange32 subRange) const;
 
      iterator begin();
      const_iterator begin() const;
 
      iterator end();
      const_iterator end() const;
 
      T* ptr();
      const T* ptr() const;
 
      template <typename T2>
      size_t find(const T2& element) const;
 
      template <typename T2>
      bool contains(const T2& element) const;
 
 
      //
      // GlobalResult functionality used by parallel kernels that create a dynamic amount of output data.
      // These are implemented in agxData/Buffer.h
      //
 
      agx::GlobalResult* getGlobalResult();
 
      agx::GlobalResult::Transaction allocateResult(size_t numElements);
      size_t commitResult(size_t numElements, const void* localResult, agx::Index sortIndex);
      size_t commitResult(size_t numElements, const void* localResult);
 
      template <typename T2>
      size_t commitResult(const T2& vector, agx::Index sortIndex);
      template <typename T2>
      size_t commitResult(const T2& vector);
 
  };
 
 
  /* Implementation */
  // See Buffer.h
}
 
#ifdef _MSC_VER
# pragma warning(pop)
#endif
 
AGX_TEMPLATED_TYPE_BINDING(agxData::Array, "Array")
 
 
#endif /* _AGXDATA_ARRAY_H_ */