vtkMemoryResourceStream.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
// SPDX-License-Identifier: BSD-3-Clause
#ifndef vtkMemoryResourceStream_h
#define vtkMemoryResourceStream_h
 
#include "vtkBuffer.h"       // vtkBuffer
#include "vtkIOCoreModule.h" // For export macro
#include "vtkResourceStream.h"
 
#include <memory>  // for std::unique_ptr
#include <string>  // for std::basic_string
#include <utility> // for std::forward
#include <vector>  // for std::vector
 
VTK_ABI_NAMESPACE_BEGIN
 
class VTKIOCORE_EXPORT vtkMemoryResourceStream : public vtkResourceStream
{
  struct BasicHolder
  {
    BasicHolder() = default;
    virtual ~BasicHolder() = default;
    BasicHolder(const BasicHolder&) = delete;
    BasicHolder& operator=(const BasicHolder&) = delete;
    BasicHolder(BasicHolder&&) noexcept = delete;
    BasicHolder& operator=(BasicHolder&&) noexcept = delete;
  };
 
  template <typename T>
  struct DataHolder : public BasicHolder
  {
    template <typename... Args>
    DataHolder(Args&&... args)
      : Data{ std::forward<Args>(args)... }
    {
    }
 
    ~DataHolder() override = default;
    DataHolder(const DataHolder&) = delete;
    DataHolder& operator=(const DataHolder&) = delete;
    DataHolder(DataHolder&&) noexcept = delete;
    DataHolder& operator=(DataHolder&&) noexcept = delete;
 
    T Data;
  };
 
  // Small utility function to easily create a DataHolder with type deduction
  template <typename T>
  static std::unique_ptr<DataHolder<T>> MakeHolder(T&& value)
  {
    return std::unique_ptr<DataHolder<T>>{ new DataHolder<T>{ std::forward<T>(value) } };
  }
 
public:
  vtkTypeMacro(vtkMemoryResourceStream, vtkResourceStream);
  static vtkMemoryResourceStream* New();
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
 
  std::size_t Read(void* buffer, std::size_t bytes) override;
  bool EndOfStream() override;
  vtkTypeInt64 Seek(vtkTypeInt64 pos, SeekDirection dir) override;
  vtkTypeInt64 Tell() override;
 
  void SetBuffer(const void* buffer, std::size_t size, bool copy = false);
 
  template <typename T>
  void SetBuffer(vtkSmartPointer<vtkBuffer<T>> buffer)
  {
    if (buffer)
    {
      this->SetBuffer(buffer->GetBuffer(), buffer->GetSize() * sizeof(T));
      this->Holder = MakeHolder(std::move(buffer));
    }
    else
    {
      this->SetBuffer(nullptr, 0);
    }
  }
 
  template <typename T, typename Allocator>
  void SetBuffer(std::vector<T, Allocator> vec)
  {
    this->SetBuffer(vec.data(), vec.size() * sizeof(T));
    this->Holder = MakeHolder(std::move(vec));
  }
 
  template <typename CharT, typename Traits, typename Allocator>
  void SetBuffer(std::basic_string<CharT, Traits, Allocator> str)
  {
    // unlike std::vector (and other containers), std::basic_string does not guarantee
    // iterators validity after a move (mainly for SSO).
    // So we have to move it prior to getting the pointer.
    auto holder = MakeHolder(std::move(str));
    this->SetBuffer(holder->Data.data(), holder->Data.size() * sizeof(CharT));
    this->Holder = std::move(holder);
  }
 
  bool OwnsBuffer() const { return this->Holder != nullptr; }
 
protected:
  vtkMemoryResourceStream();
  ~vtkMemoryResourceStream() override = default;
  vtkMemoryResourceStream(const vtkMemoryResourceStream&) = delete;
  vtkMemoryResourceStream& operator=(const vtkMemoryResourceStream&) = delete;
 
private:
  const unsigned char* Buffer = nullptr; // for pointer arithmetic
  std::size_t Size = 0;
  vtkTypeInt64 Pos = 0;
  bool Eos = false;
  std::unique_ptr<BasicHolder> Holder;
};
 
VTK_ABI_NAMESPACE_END
 
#endif