data_storage.hpp

Go to the documentation of this file.

/*
 * Copyright (C) 1998-2018 ALPS Collaboration. See COPYRIGHT.TXT
 * All rights reserved. Use is subject to license terms. See LICENSE.TXT
 * For use in publications, see ACKNOWLEDGE.TXT
 */

#ifndef ALPSCORE_GF_TENSORBASE_H
#define ALPSCORE_GF_TENSORBASE_H

#include <vector>

namespace alps {
  namespace numerics {
    namespace detail {

      // Forward declarations
      template<typename T>
      class data_view;

      template<typename T, typename Cont = std::vector<typename std::remove_const<T>::type> >
      class data_storage {
      private:
        Cont data_;
      public:

        template<typename T2, typename C2>
        data_storage(const data_storage<T2, C2> & storage) : data_(storage.size()) {
          std::copy(storage.data(), storage.data() + storage.size(), data());
        };
        template<typename T2, typename C2>
        data_storage(data_storage<T2, C2> && storage) : data_(storage.size()) {
          std::copy(storage.data(), storage.data() + storage.size(), data());
        };

        data_storage(const data_storage<T, Cont>& rhs) : data_(rhs.data_) {};
        data_storage(data_storage<T, Cont>&& rhs) : data_(rhs.data_) {};
        data_storage<T, Cont>& operator=(const data_storage<T, Cont>& rhs) {
          if(size() != rhs.size()) {
            resize(rhs.size());
          }
          std::copy(rhs.data(), rhs.data() + rhs.size(), data());
          return *this;
        };
        data_storage<T, Cont>& operator=(data_storage<T, Cont>&& rhs) {
          if(size() != rhs.size()) {
            resize(rhs.size());
          }
          std::copy(rhs.data(), rhs.data() + rhs.size(), data());
          return *this;
        };

        template<typename T2, typename C2>
        data_storage<T, Cont>& operator=(const data_storage<T2, C2>& rhs) {
          static_assert(std::is_convertible<T2, T>::value, "Can not perform assignment: T2 can not be cast into T");
          if(size() != rhs.size()) {
            resize(rhs.size());
          }
          std::copy(rhs.data(), rhs.data() + rhs.size(), data());
          return *this;
        };
        template<typename T2>
        data_storage(const data_view<T2> & view)  : data_(view.size()) {
          static_assert(std::is_convertible<T2, T>::value, "View type can not be converted into storage");
          std::copy(view.data(), view.data() + view.size(), data());
        }
        template<typename T2>
        data_storage(data_view<T2> && view) noexcept  : data_(view.size()){
          std::copy(view.data(), view.data() + view.size(), data());
        };
        data_storage(const T *data, size_t size) : data_(size) {
          std::copy(data, data + size, this->data());
        }
        explicit data_storage(size_t size) : data_(size) {
          std::fill(data(), data()+size, T(0));
        }

        inline T& data(size_t i) {
          return data_[i];
        };
        inline const T& data(size_t i) const {return data_[i];};
        inline const T& operator()(size_t i) const {return data_[i];};
        inline T& operator()(size_t i) {
          return data_[i];
        };
        size_t size() const {return data_.size();}
        const T* data() const {return data_.data();}
        T* data() {return data_.data();}
        void resize(size_t new_size) {
          data_.resize(new_size);
        }

        template<typename T2, typename C2>
        bool operator==(const data_storage<T2, C2> &r) const {
          return r.size() == size() && std::equal(r.data(), r.data() + r.size(), data());
        }

        template<typename T2>
        bool operator==(const data_view<T2>& r) const {
          return r == *this;
        };
      };
    }
    template<typename T>
    using simple_storage = detail::data_storage<T, std::vector<T> >;
  }
}

#endif //ALPSCORE_GF_TENSORBASE_H