StorageView.h

Go to the documentation of this file.

//===-- serialbox/core/StorageView.h ------------------------------------------------*- C++ -*-===//
//
//                                    S E R I A L B O X
//
// This file is distributed under terms of BSD license.
// See LICENSE.txt for more information.
//
//===------------------------------------------------------------------------------------------===//
//
//===------------------------------------------------------------------------------------------===//

#ifndef SERIALBOX_CORE_STORAGEVIEW_H
#define SERIALBOX_CORE_STORAGEVIEW_H

#include "serialbox/core/Logging.h"
#include "serialbox/core/STLExtras.h"
#include "serialbox/core/Slice.h"
#include "serialbox/core/StorageViewIterator.h"
#include "serialbox/core/Type.h"
#include <utility>
#include <vector>

namespace serialbox {


class StorageView {
public:

  StorageView(void* originPtr, TypeID type, const std::vector<int>& dims,
              const std::vector<int>& strides);

  StorageView(void* originPtr, TypeID type, std::vector<int>&& dims, std::vector<int>&& strides);

  StorageView(const StorageView& other) = default;

  StorageView(StorageView&& other) = default;


  StorageViewIterator begin() noexcept {
    return StorageViewIterator(originPtr_, bytesPerElement(), dims_, strides_, slice_, true);
  }
  ConstStorageViewIterator begin() const noexcept {
    return ConstStorageViewIterator(originPtr_, bytesPerElement(), dims_, strides_, slice_, true);
  }

  StorageViewIterator end() noexcept {
    return StorageViewIterator(originPtr_, bytesPerElement(), dims_, strides_, slice_, false);
  }
  ConstStorageViewIterator end() const noexcept {
    return ConstStorageViewIterator(originPtr_, bytesPerElement(), dims_, strides_, slice_, false);
  }


  template <class T>
  T* originPtrAs() noexcept {
    return (T*)(originPtr_);
  }
  template <class T>
  const T* originPtrAs() const noexcept {
    return (T*)(originPtr_);
  }

  Byte* originPtr() noexcept { return originPtr_; }
  const Byte* originPtr() const noexcept { return originPtr_; }

  TypeID type() const noexcept { return type_; }

  int bytesPerElement() const noexcept { return TypeUtil::sizeOf(type_); }

  const std::vector<int>& dims() const noexcept { return dims_; }

  const std::vector<int>& strides() const noexcept { return strides_; }


  StorageView& operator=(const StorageView& other) = default;

  StorageView& operator=(StorageView&& other) = default;

  void swap(StorageView& other) noexcept;

  bool operator==(const StorageView& right) const noexcept;

  bool operator!=(const StorageView& right) const noexcept { return (!(*this == right)); }

  friend std::ostream& operator<<(std::ostream& stream, const StorageView& s);


  void setSlice(Slice slice);

  Slice& getSlice() noexcept { return slice_; }
  const Slice& getSlice() const noexcept { return slice_; }

  bool isMemCopyable() const noexcept;

  std::size_t size() const noexcept;

  std::size_t sizeInBytes() const noexcept;

private:
  Byte* originPtr_;          
  TypeID type_;              
  std::vector<int> dims_;    
  std::vector<int> strides_; 
  Slice slice_;              
};

void swap(StorageView& a, StorageView& b) noexcept;


} // namespace serialbox

#endif