CaVector.h

Go to the documentation of this file.

/* Copyright (C) 2021-2023 GSI Helmholtzzentrum fuer Schwerionenforschung, Darmstadt
   SPDX-License-Identifier: GPL-3.0-only
   Authors: Sergey Gorbunov [committer], Sergei Zharko */

 
//#pragma once  // include this header only once per compilation unit (not robust)
 
#ifndef CA_CORE_CaVector_h
#define CA_CORE_CaVector_h 1
 
#include "AlgoFairloggerCompat.h"
 
#include <boost/serialization/access.hpp>
#include <boost/serialization/base_object.hpp>
#include <boost/serialization/string.hpp>
#include <boost/serialization/vector.hpp>
 
#include <memory>
#include <sstream>
 
namespace cbm::algo::ca
{
  template<class T>
  class Vector : private std::vector<T> {
    friend class boost::serialization::access;
 
   public:
    using Tbase                  = std::vector<T>;
    using value_type             = T;
    using allocator_type         = typename Tbase::allocator_type;
    using pointer                = typename std::allocator_traits<allocator_type>::pointer;
    using const_pointer          = typename std::allocator_traits<allocator_type>::const_pointer;
    using reference              = value_type&;
    using const_reference        = const value_type&;
    using size_type              = typename Tbase::size_type;
    using difference_type        = typename Tbase::difference_type;
    using iterator               = typename Tbase::iterator;
    using const_iterator         = typename Tbase::const_iterator;
    using reverse_iterator       = std::reverse_iterator<iterator>;
    using const_reverse_iterator = std::reverse_iterator<const_iterator>;
 

    template<typename... Tinput>
    Vector(Tinput... value) : Tbase(value...)
    {
    }

    template<typename... Tinput>
    Vector(const char* name, Tinput... value) : Tbase(value...)
                                              , fName(name)
    {
    }

    Vector(const std::string& name, std::initializer_list<T> init) : Tbase(init), fName(name) {}

    Vector(const Vector& v) : Tbase() { *this = v; }

    Vector(Vector&& v) noexcept : Tbase(std::move(v)), fName(std::move(v.fName)) {}

    Vector& operator=(const Vector& v)
    {
      if (this != &v) {
        fName = v.fName;
        Tbase::reserve(v.capacity());  // make sure that the capacity is transmitted
        Tbase::assign(v.begin(), v.end());
      }
      return *this;
    }

    Vector& operator=(Vector&& v) noexcept
    {
      if (this != &v) {
        std::swap(fName, v.fName);
        Tbase::swap(v);
      }
      return *this;
    }

    void swap(Vector& v) noexcept
    {
      if (this != &v) {
        std::swap(fName, v.fName);
        Tbase::swap(v);
      }
    }

    void SetName(const std::string& s) { fName = s; }

    void SetName(const std::basic_ostream<char>& s)
    {
      // helps to set a composed name in a single line via:
      // SetName(std::stringstream()<<"my name "<<..whatever..);
      fName = dynamic_cast<const std::stringstream&>(s).str();
    }

    std::string GetName() const
    {
      std::string s = "ca::Vector<";
      s += fName + "> ";
      return s;
    }

    template<typename... Tinput>
    void reset(std::size_t count, Tinput... value)
    {
      // does the same as Tbase::assign(), but works with the default T constructor too
      // (no second parameter)
      Tbase::clear();
      Tbase::resize(count, value...);
    }

    template<typename... Tinput>
    void enlarge(std::size_t count, Tinput... value)
    {
      if (count < Tbase::size()) {
        LOG(fatal) << "ca::Vector \"" << fName << "\"::enlarge(" << count
                   << "): the new size is smaller than the current one " << Tbase::size() << ", something goes wrong.";
        assert(count >= Tbase::size());
      }
      if ((!Tbase::empty()) && (count > Tbase::capacity())) {
        LOG(warning) << "ca::Vector \"" << fName << "\"::enlarge(" << count << "): allocated capacity of "
                     << Tbase::capacity() << " is reached, the vector of size " << Tbase::size()
                     << " will be copied to the new place.";
      }
      Tbase::resize(count, value...);
    }

    void shrink(std::size_t count)
    {
      if (count > Tbase::size()) {
        LOG(fatal) << "ca::Vector \"" << fName << "\"::shrink(" << count
                   << "): the new size is bigger than the current one " << Tbase::size() << ", something goes wrong.";
        assert(count < Tbase::size());
      }
      Tbase::resize(count);
    }

    void reserve(std::size_t count)
    {
      if (!Tbase::empty()) {
        LOG(fatal) << "ca::Vector \"" << fName << "\"::reserve(" << count << "): the vector is not empty; "
                   << " it will be copied to the new place.";
        assert(Tbase::empty());
      }
      Tbase::reserve(count);
    }

    template<typename Tinput>
    void push_back(Tinput value)
    {
      if (Tbase::size() >= Tbase::capacity()) {
        LOG(warning) << "ca::Vector \"" << fName << "\"::push_back(): allocated capacity of " << Tbase::capacity()
                     << " is reached, re-allocate and copy.";
      }
      Tbase::push_back(value);
    }

    template<typename Tinput>
    void push_back_no_warning(Tinput value)
    {
      Tbase::push_back(value);
    }

    template<typename... Tinput>
    void emplace_back(Tinput&&... value)
    {
      if (Tbase::size() >= Tbase::capacity()) {
        LOG(warning) << "ca::Vector \"" << fName << "\"::emplace_back(): allocated capacity of " << Tbase::capacity()
                     << " is reached, re-allocate and copy.";
      }
      Tbase::emplace_back(value...);
    }

    T& operator[](std::size_t pos)
    {
      if (pos >= Tbase::size()) {
        LOG(fatal) << "ca::Vector \"" << fName << "\": trying to access element " << pos
                   << " outside of the vector of the size of " << Tbase::size();
        assert(pos < Tbase::size());
      }
      return Tbase::operator[](pos);
    }

    const T& operator[](std::size_t pos) const
    {
      if (pos >= Tbase::size()) {
        LOG(fatal) << "ca::Vector \"" << fName << "\": trying to access element " << pos
                   << " outside of the vector of the size of " << Tbase::size();
        assert(pos < Tbase::size());
      }
      return Tbase::operator[](pos);
    }

    T& back()
    {
      if (Tbase::size() == 0) {
        LOG(fatal) << "ca::Vector \"" << fName << "\": trying to access element of an empty vector";
        assert(Tbase::size() > 0);
      }
      return Tbase::back();
    }

    const T& back() const
    {
      if (Tbase::size() == 0) {
        LOG(fatal) << "ca::Vector \"" << fName << "\": trying to access element of an empty vector";
        assert(Tbase::size() > 0);
      }
      return Tbase::back();
    }
 
    using Tbase::begin;
    using Tbase::capacity;
    using Tbase::cbegin;
    using Tbase::cend;
    using Tbase::clear;
    using Tbase::end;
    using Tbase::insert;  //TODO:: make it private
    using Tbase::pop_back;
    using Tbase::rbegin;
    using Tbase::reserve;
    using Tbase::shrink_to_fit;
    using Tbase::size;
 
 
   private:
    std::string fName{"no name"};  
    using Tbase::assign;           // use reset() instead
    using Tbase::at;
    using Tbase::resize;

    template<class Archive>
    void serialize(Archive& ar, const unsigned int /*version*/)
    {
      ar& boost::serialization::base_object<Tbase>(*this);
      ar& fName;
    }
  };

  template<>
  class Vector<bool> {
  };
}  // namespace cbm::algo::ca
 
#endif  // CA_CORE_CaVector_h