VectorWithOffset.h

Go to the documentation of this file.

//
//
/*
    Copyright (C) 2000 PARAPET partners
    Copyright (C) 2000 - 2007-10-08, Hammersmith Imanet Ltd
    Copyright (C) 2012-06-01 - 2012, Kris Thielemans
    Copyright (C) 2023 - 2025, University College London
    This file is part of STIR.
 
    SPDX-License-Identifier: Apache-2.0 AND License-ref-PARAPET-license
    See STIR/LICENSE.txt for details
*/
#ifndef __stir_VectorWithOffset_H__
#define __stir_VectorWithOffset_H__

 
#include "stir/shared_ptr.h"
#include "stir/deprecated.h"
#include <iterator>
 
START_NAMESPACE_STIR

 
template <class T>
class VectorWithOffset
{
public:

  typedef T value_type;
  typedef value_type& reference;
  typedef const value_type& const_reference;
  typedef ptrdiff_t difference_type;
  typedef T* iterator;
  typedef T const* const_iterator;
 
  typedef std::reverse_iterator<iterator> reverse_iterator;
  typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
  typedef size_t size_type;
 
public:
  inline VectorWithOffset();

  inline explicit VectorWithOffset(const int hsz);

  inline VectorWithOffset(const int min_index, const int max_index);
 
#if STIR_VERSION < 070000

  STIR_DEPRECATED VectorWithOffset(const int hsz, T* const data_ptr, T* const end_of_data_ptr);


  STIR_DEPRECATED inline VectorWithOffset(const int min_index, const int max_index, T* const data_ptr, T* const end_of_data_ptr);
#endif

  VectorWithOffset(const int hsz, const T* const data_ptr);

  inline VectorWithOffset(const int min_index, const int max_index, const T* const data_ptr);


  inline VectorWithOffset(const int min_index, const int max_index, shared_ptr<T[]> data_sptr);


  inline VectorWithOffset(const int sz, shared_ptr<T[]> data_sptr)
      : VectorWithOffset(0, sz - 1, data_sptr)
  {}

  inline VectorWithOffset(const VectorWithOffset& il);

  inline virtual ~VectorWithOffset();

  // implementation in .h because of templates/friends/whatever, see https://stackoverflow.com/a/61020224
  friend inline void swap(VectorWithOffset& first, VectorWithOffset& second) // nothrow
  {
    using std::swap;
    //  swap the members of two objects
    swap(first.num, second.num);
    swap(first.length, second.length);
    swap(first.start, second.start);
    swap(first.begin_allocated_memory, second.begin_allocated_memory);
    swap(first.end_allocated_memory, second.end_allocated_memory);
    swap(first.pointer_access, second.pointer_access);
    swap(first.allocated_memory_sptr, second.allocated_memory_sptr);
  }


  VectorWithOffset(VectorWithOffset&& other) noexcept;


  inline void recycle();


  inline VectorWithOffset& operator=(const VectorWithOffset& il);



  inline int get_length() const;

  inline size_t size() const;

  inline int get_min_index() const;

  inline int get_max_index() const;

  inline void set_offset(const int min_index);

  inline void set_min_index(const int min_index);


  inline virtual void grow(const int min_index, const int max_index);

  inline void grow(const unsigned int new_size);


  inline virtual void resize(const int min_index, const int max_index);

  inline void resize(const unsigned int new_size);

  inline void reserve(const int min_index, const int max_index);

  inline void reserve(const unsigned int new_size);

  inline size_t capacity() const;


  inline bool owns_memory_for_data() const;


  inline int get_capacity_min_index() const;


  inline int get_capacity_max_index() const;

  inline T& operator[](int i);

  inline const T& operator[](int i) const;

  inline T& at(int i);

  inline const T& at(int i) const;

  inline bool empty() const;


  inline bool operator==(const VectorWithOffset& iv) const;
  inline bool operator!=(const VectorWithOffset& iv) const;

  inline void fill(const T& n);

  inline void apply_lower_threshold(const T& lower);

  inline void apply_upper_threshold(const T& upper);



  inline T* get_data_ptr();

  inline const T* get_const_data_ptr() const;

  inline void release_data_ptr();

  inline void release_const_data_ptr() const;



  inline iterator begin();
  inline const_iterator begin() const;
  inline iterator end();
  inline const_iterator end() const;
 
  inline reverse_iterator rbegin();
  inline reverse_iterator rend();
  inline const_reverse_iterator rbegin() const;
  inline const_reverse_iterator rend() const;


  inline VectorWithOffset& operator+=(const VectorWithOffset& v);

  inline VectorWithOffset& operator-=(const VectorWithOffset& v);

  inline VectorWithOffset& operator*=(const VectorWithOffset& v);

  inline VectorWithOffset& operator/=(const VectorWithOffset& v);
#if 0
  // next operators are disabled for now
  // if enabling then, you should also put them in NumericVectorWithOffset probably

  inline VectorWithOffset & operator+= (const T &t);

  inline VectorWithOffset & operator-= (const T &t);

  inline VectorWithOffset & operator*= (const T &t);

  inline VectorWithOffset & operator/= (const T &t);
#endif


  inline VectorWithOffset operator+(const VectorWithOffset& v) const;

  inline VectorWithOffset operator-(const VectorWithOffset& v) const;

  inline VectorWithOffset operator*(const VectorWithOffset& v) const;

  inline VectorWithOffset operator/(const VectorWithOffset& v) const;
 
protected:
  T* num; // TODO make private

  inline void check_state() const;

  inline void init_with_copy(const int min_index, const int max_index, T const* const data_ptr);

  inline void init(const int min_index, const int max_index, T* const data_ptr, bool copy_data);
 
private:
  unsigned int length;
  int start;
 
  T* begin_allocated_memory;
  T* end_allocated_memory;

  shared_ptr<T[]> allocated_memory_sptr;

  inline void init();

  inline void _destruct_and_deallocate();

  // This variable is declared mutable such that get_const_data_ptr() can change it.
  mutable bool pointer_access;
};
 
END_NAMESPACE_STIR
 
#include "stir/VectorWithOffset.inl"
 
#endif // __VectorWithOffset_H__