databuffer.h

Go to the documentation of this file.

// Copyright 2017-2020, Schlumberger
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
 
#pragma once
 
#include "../declspec.h"
#include "enum.h"
#include "types.h"
 
#include <cstdint>
#include <array>
#include <memory>
#include <string>
 
namespace InternalZGY {
#if 0
}
#endif
 
class OPENZGY_TEST_API DataBuffer
{
public:
    enum flags_t {C_ORDERING=1, CONTIGUOUS=2, POSITIVE_STRIDE=4, DEGENERATE=8};
public:
  //** No copy or assign in the abstract base class.
  DataBuffer(const DataBuffer&) = delete;
  //** No copy or assign in the abstract base class.
  DataBuffer& operator=(const DataBuffer&) = delete;
  DataBuffer() = default;
  virtual ~DataBuffer();
  virtual std::string  toString()  const = 0;
  virtual std::shared_ptr<void>        voidData()        = 0;
  virtual std::shared_ptr<const void>  voidData()  const = 0;
  //** True if there are no holes and the internal buffer can be treated as 1d.
  virtual bool         contiguous() const = 0;
  //** Number of elements including holes. Computed from size() and stride().
  virtual std::int64_t allocsize() const = 0;
  //** Number of elements. Computed as the product of size() in each dimension.
  virtual std::int64_t totalsize() const = 0;
  //** Size in bytes of one element.
  virtual std::int64_t itemsize()  const = 0;
  //** Number of elements as an unsafe (unchecked length) pointer.
  virtual const std::int64_t* sizeptr() const = 0;
  //** Buffer layout as an unsafe (unchecked length) pointer.
  virtual const std::int64_t* strideptr() const = 0;
  //** Number of elements in each of the (assumed) 3 dimensions
  virtual std::array<std::int64_t,3> size3d() const = 0;
  //** Buffer layout in each of the (assumed) 3 dimensions
  virtual std::array<std::int64_t,3> stride3d() const = 0;
  //** True if data() has proper reference counting. TODO-Medium: Rename, or yagni.
  virtual bool ownsdata() const = 0;
  //** True if buffer represents a constant value. data() will be length 1.
  virtual bool isScalar() const = 0;
  //** True if buffer is not scalar but samples are all the same.
  virtual bool isAllSame(const std::int64_t *used_in) const = 0;
  //** The constant value, if any, as a double. Unspecified if !isScalar().
  virtual double scalarAsDouble() const = 0;
  //** Convert the templated Type argument of the leaf class to an enum.
  virtual RawDataType datatype() const = 0;
  //** Set all samples to the same value.
  virtual void fill(double value) = 0;
  //** Make the instance unusable. May be needed if data is not ref counted.
  virtual void clear() = 0;
  //** Value range excluding infinites and nan.
  virtual std::pair<double, double> range() const = 0;
  virtual void copyFrom(
            const DataBuffer* src,
            const std::int64_t *srcorig,const std::int64_t *dstorig,
            const std::int64_t *cpyorig,const std::int64_t *cpysize) = 0;
  //std::int64_t ni() const { return size()[0]; }
  //std::int64_t nj() const { return size()[1]; }
  //std::int64_t nk() const { return size()[2]; }
  virtual std::shared_ptr<DataBuffer> clone() const = 0;
  virtual std::shared_ptr<DataBuffer> scaleToFloat(const std::array<double,2>&) = 0;
  virtual std::shared_ptr<DataBuffer> scaleToStorage(const std::array<double,2>&, RawDataType) = 0;
  virtual std::uint32_t layout() const = 0;
  virtual bool is_cstride() const = 0;
  virtual void check_cstride() const = 0;
  virtual std::shared_ptr<DataBuffer> slice1(int dim, std::int64_t start, std::int64_t size) const = 0;
  static std::shared_ptr<DataBuffer> makeDataBuffer3d(void *raw, std::int64_t nbytes, const std::array<std::int64_t,3>& size, RawDataType dtype);
};
 
template <typename T, int NDim>
class DataBufferNd : public DataBuffer
{
public:
  typedef T value_type;
  typedef DataBufferNd<T, NDim> self_type;
  typedef std::array<std::int64_t,NDim> ndsize_t;
  enum { ndim = NDim };
 
  // TODO-Low: Group functions better.
public: // These are only available in the templated class.
  //** Default copy/assign would work, but don't offer it if I don't need it.
  DataBufferNd(const self_type&) = delete;
  //** Default copy/assign would work, but don't offer it if I don't need it.
  self_type& operator=(const self_type&) = delete;
  //** Buffer represents a constant value. No allocated data.
  DataBufferNd(T scalar, const std::array<std::int64_t,NDim>& size);
  //** Allocate a new buffer and take ownership of it.
  DataBufferNd(const std::array<std::int64_t,NDim>& size);
  //** Allocate a new buffer and take ownership of it, with non-standard stride.
  DataBufferNd(const std::array<std::int64_t,NDim>& size, const std::array<std::int64_t,NDim>& stride);
  //** External buffer, shared ownership. Beware we might get a "fake" smartptr.
  DataBufferNd(const std::shared_ptr<T>& data, const std::array<std::int64_t,NDim>& size);
  //** External buffer, shared ownership. Beware we might get a "fake" smartptr.
  DataBufferNd(const std::shared_ptr<T>& data, const std::array<std::int64_t,NDim>& size, const std::array<std::int64_t,NDim>& stride);
  //** Plain, strongly typed pointer to data.
  T* data() { return _data.get(); }
  //** Plain, strongly typed pointer to data.
  const T* data() const { return _data.get(); }
  //** The constant value, if any. Return first value if !isScalar().
  T scalarValue() const { return data()[0]; }
  //** True if we know data() has proper reference counting because we allocated it.
  virtual bool ownsdata() const {return _ownsdata; }
  //** True if buffer represents a constant value.
  bool isScalar() const override { return _is_scalar; }
  //** True if buffer is not scalar but samples are all the same.
  bool isAllSame(const std::int64_t *used_in) const override;
  //** The constant value, if any, as a double.
  double scalarAsDouble() const override { return (double)scalarValue(); }
  RawDataType datatype() const override { return RawDataTypeTraits<T>::datatype; }
  void fill(double value) override;
  void clear() override;
  std::pair<double, double> range() const override;
  std::uint32_t layout() const override;
  bool is_cstride() const override;
  void check_cstride() const override;
 
private:
  ndsize_t _size;
  ndsize_t _stride;
  bool _is_scalar;
  std::shared_ptr<T> _data;
  bool _ownsdata;
 
  static std::uint32_t check_stride(const ndsize_t& size, const ndsize_t& stride);
  static ndsize_t cstride(const ndsize_t& size);
  static ndsize_t make_array(const std::int64_t *in);
  static std::int64_t make_product(const ndsize_t& size);
  static std::int64_t make_allocsize(const ndsize_t& size, const ndsize_t& stride);
 
public:
  std::string  toString()  const override;
  std::shared_ptr<void> voidData()        override { return _data; }
  std::shared_ptr<const void> voidData()  const override { return _data; }
  bool contiguous() const override;
  std::int64_t allocsize() const override;
  std::int64_t totalsize() const override;
  std::int64_t itemsize() const override;
  const std::int64_t* sizeptr() const override;
  const std::int64_t* strideptr() const override;
  std::array<std::int64_t,3> size3d() const override;
  std::array<std::int64_t,3> stride3d() const override;
  const ndsize_t& safesize() const {return _size;}
  const ndsize_t& safestride() const {return _stride;}
  std::shared_ptr<DataBuffer> clone() const;
  std::shared_ptr<DataBuffer> scaleToFloat(const std::array<double,2>&) override;
  std::shared_ptr<DataBuffer> scaleToStorage(const std::array<double,2>&, RawDataType) override;
  std::shared_ptr<DataBuffer> slice1(int dim, std::int64_t start, std::int64_t size) const override;
 
  std::shared_ptr<self_type> slice(const ndsize_t& neworig,
                                   const ndsize_t& newsize) const;
 
  void copyFrom(const DataBuffer* src,
                const std::int64_t *srcorig,const std::int64_t *dstorig,
                const std::int64_t *cpyorig,const std::int64_t *cpysize);
 
  static void copySubset(const ndsize_t& srcorig, const self_type& src,
                         const ndsize_t& dstorig,       self_type& dst,
                         const ndsize_t& cpyorig, const ndsize_t& cpysize);
 
  static void copySubset(const ndsize_t& srcorig, const self_type& src,
                         const ndsize_t& dstorig,       self_type& dst);
 
public:
  // Logically private, but needs to be available from a DteBufferNd with different template arguments. Easier to make them public.
  static std::shared_ptr<DataBuffer> s_scaleToFloat(const DataBuffer*, const std::array<double,2>&);
  static std::shared_ptr<DataBuffer> s_scaleFromFloat(const DataBuffer*, const std::array<double,2>&);
};
 
// Explicit template instanciation.
OPENZGY_DECLARE_EXPLICIT_TEMPLATE(DataBufferNd<std::int8_t, 3>)
OPENZGY_DECLARE_EXPLICIT_TEMPLATE(DataBufferNd<std::uint8_t, 3>)
OPENZGY_DECLARE_EXPLICIT_TEMPLATE(DataBufferNd<std::int16_t, 3>)
OPENZGY_DECLARE_EXPLICIT_TEMPLATE(DataBufferNd<std::uint16_t, 3>)
OPENZGY_DECLARE_EXPLICIT_TEMPLATE(DataBufferNd<std::int32_t, 3>)
OPENZGY_DECLARE_EXPLICIT_TEMPLATE(DataBufferNd<std::uint32_t, 3>)
OPENZGY_DECLARE_EXPLICIT_TEMPLATE(DataBufferNd<float, 3>)
 
} // namespace