VectorX.h

#pragma once
 
#include <iolink/IOLinkAPI.h>
 
#include <array>
#include <cstdint>
#include <initializer_list>
#include <iostream>
 
namespace iolink
{
 
template <typename T>
class VectorX final
{
public:
  using ValueType = T;
 
  using Iterator = ValueType*;
  using ConstIterator = const ValueType*;
 
  static VectorX createUniform(size_t size, ValueType value);
 
  VectorX();
 
  explicit VectorX(size_t size);
 
  VectorX(std::initializer_list<ValueType> init);
 
  template <typename U>
  explicit VectorX(const VectorX<U>& other)
      : VectorX(other.size())
  {
    for (size_t i = 0; i < m_size; ++i)
    {
      m_data[i] = static_cast<ValueType>(other[i]);
    }
  }
 
  VectorX(const VectorX& other);
  VectorX& operator=(const VectorX& other);
 
  VectorX(VectorX&& other) noexcept;
  VectorX& operator=(VectorX&& other) noexcept;
 
  ~VectorX();
 
  inline size_t size() const { return m_size; }
 
  inline ValueType at(size_t index) const { return m_data[index]; }
 
  inline void setAt(size_t index, ValueType value) { m_data[index] = value; }
 
  inline ValueType& operator[](size_t index) { return m_data[index]; }
  inline ValueType operator[](size_t index) const { return m_data[index]; }
 
  inline Iterator begin() noexcept { return m_data; }
  inline ConstIterator begin() const noexcept { return m_data; }
  inline Iterator end() noexcept { return static_cast<Iterator>(m_data + m_size); }
  inline ConstIterator end() const noexcept { return static_cast<ConstIterator>(m_data + m_size); }
 
  inline ValueType* data() { return m_data; }
 
  inline const ValueType* data() const { return m_data; }
 
  bool operator==(const VectorX& other) const;
  bool operator!=(const VectorX& other) const;
 
  double squaredLength() const;
 
  double length() const;
 
  void normalize();
 
  std::string toString() const;
 
  // ==================== //
  // Arithmetic operators //
  // ==================== //
 
  VectorX operator-() const;
 
  VectorX& operator+=(const VectorX& v);
  VectorX& operator-=(const VectorX& v);
 
  inline VectorX operator+(const VectorX& v) const { return VectorX(*this) += v; }
  inline VectorX operator-(const VectorX& v) const { return VectorX(*this) -= v; }
 
  VectorX& operator*=(ValueType value);
  VectorX& operator/=(ValueType value);
 
  inline VectorX operator*(ValueType s) const { return VectorX(*this) *= s; }
  inline VectorX operator/(ValueType s) const { return VectorX(*this) /= s; }
 
  friend inline VectorX operator*(ValueType s, VectorX v) { return v *= s; }
 
  ValueType dot(const VectorX& v) const;
 
  VectorX cross(const VectorX& v) const;
 
  // ==================== //
  // GLSL style operators //
  // ==================== //
 
  VectorX& operator*=(const VectorX& v);
  VectorX& operator/=(const VectorX& v);
 
  inline VectorX operator*(const VectorX& v) const { return VectorX(*this) *= v; }
  inline VectorX operator/(const VectorX& v) const { return VectorX(*this) /= v; }
 
  bool operator<(const VectorX& other) const;
  bool operator<=(const VectorX& other) const;
  bool operator>(const VectorX& other) const;
  bool operator>=(const VectorX& other) const;
 
private:
  size_t m_size;
 
  // Pointer on values. If m_size < m_array.size(), it point to array. Else,
  // it point to memory allocated on heap with new[].
  // In case m_data != m_array.data(), it should be deallocated with delete[]
  ValueType* m_data;
 
  // 4 sized array storing values if VectorX size is < 4.
  // This avoid allocating values on heap and greatly optimise VectorX in most common case.
  std::array<ValueType, 4> m_array;
};
 
template <typename T>
inline std::ostream&
operator<<(std::ostream& os, const VectorX<T>& v)
{
  os << v.toString();
  return os;
}
 
// ===================== //
// Template declarations //
// ===================== //
 
extern template class IOLINK_API_IMPORT VectorX<uint8_t>;
extern template class IOLINK_API_IMPORT VectorX<int8_t>;
extern template class IOLINK_API_IMPORT VectorX<uint16_t>;
extern template class IOLINK_API_IMPORT VectorX<int16_t>;
extern template class IOLINK_API_IMPORT VectorX<uint32_t>;
extern template class IOLINK_API_IMPORT VectorX<int32_t>;
extern template class IOLINK_API_IMPORT VectorX<uint64_t>;
extern template class IOLINK_API_IMPORT VectorX<int64_t>;
extern template class IOLINK_API_IMPORT VectorX<float>;
extern template class IOLINK_API_IMPORT VectorX<double>;
 
//==================== //
// Aliases declaration //
//==================== //
 
using VectorXu8 = VectorX<uint8_t>;   
using VectorXu16 = VectorX<uint16_t>; 
using VectorXu32 = VectorX<uint32_t>; 
using VectorXu64 = VectorX<uint64_t>; 
using VectorXi8 = VectorX<int8_t>;    
using VectorXi16 = VectorX<int16_t>;  
using VectorXi32 = VectorX<int32_t>;  
using VectorXi64 = VectorX<int64_t>;  
using VectorXf = VectorX<float>;      
using VectorXd = VectorX<double>;     
 
} // end namespace iolink