bulk.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 <memory>
#include <functional>
#include <array>
#include <vector>
#include <tuple>
#include <sstream>
 
namespace Test { class TestBulk; }
namespace InternalZGY {
#if 0
}
#endif
 
class FileADT;
class ZgyInternalMeta;
class DataBuffer;
struct IJK;
struct LutInfoEx;
 
class OPENZGY_TEST_API ZgyInternalBulk
{
  friend class Test::TestBulk;
public:
  typedef std::function<bool(int, const std::string&)> LoggerFn;
 
private:
  class ErrorsWillCorruptFile;
  std::shared_ptr<FileADT>         _file;
  std::shared_ptr<ZgyInternalMeta> _metadata;
  UpdateMode _update_mode;
  bool       _compressed_write; // If true: do not align bricks.
  bool       _is_bad;           // If true: instance not usable.
  double     _written_sample_min;
  double     _written_sample_max;
  LoggerFn   _loggerfn;
 
public:
  ZgyInternalBulk(
      const std::shared_ptr<FileADT>& file,
      const std::shared_ptr<ZgyInternalMeta>& metadata,
      bool compressed_write,
      const LoggerFn& logger = LoggerFn());
 
  std::pair<bool,double> readConstantValue(
      const std::array<std::int64_t,3>& start,
      const std::array<std::int64_t,3>& size,
      int32_t lod, bool as_float);
 
  void readToExistingBuffer(
      const std::shared_ptr<DataBuffer>& data,
      const std::array<std::int64_t,3>& start,
      int32_t lod, bool as_float);
 
  std::shared_ptr<DataBuffer> readToNewBuffer(
      const std::array<std::int64_t,3>& start,
      const std::array<std::int64_t,3>& size,
      int32_t lod, bool as_float, bool check_constant);
 
  void writeRegion(
      const std::shared_ptr<DataBuffer>& data,
      const std::array<std::int64_t,3>& start,
      int32_t lod, bool is_storage,
      const compressor_t& compressor);
 
public: // actually internal
 
  bool errorflag() const        { return _is_bad; }
  void set_errorflag(bool flag) { _is_bad = flag; }
  LoggerFn set_logger(const LoggerFn& logger) {
    LoggerFn old = _loggerfn;
    _loggerfn = logger;
    return old;
  }
  std::array<double,2> valueRangeWritten() const {
    return std::array<double,2>{_written_sample_min, _written_sample_max};
  }
 
private:
 
  bool _logger(int priority, const std::string& ss = std::string()) const;
 
  bool _logger(int priority, const std::ios& ss) const;
 
  void _validateUserPosition(
      const std::array<std::int64_t,3>& start,
      const std::array<std::int64_t,3>& size,
      int32_t lod);
 
  std::shared_ptr<DataBuffer> _scaleDataToFloat(
      const std::shared_ptr<DataBuffer>& data);
 
  std::shared_ptr<DataBuffer> _scaleDataToStorage(
      const std::shared_ptr<DataBuffer>& data);
 
  static double _decodeConstant(std::uint32_t in, RawDataType dtype);
 
  static std::int32_t _encodeConstant(double in, RawDataType dtype);
 
  std::vector<LutInfoEx> _partsNeeded(
      const std::array<std::int64_t,3>& start,
      const std::array<std::int64_t,3>& size,
      int32_t lod);
 
  void _deliverOneBrick(
      const std::shared_ptr<DataBuffer>& result,
      const std::array<std::int64_t,3>& start,
      const std::array<std::int64_t,3>& startpos,
      const void *raw, std::int64_t rawsize,
      BrickStatus brickstatus, bool as_float);
 
  // --- WRITE SUPPORT ---
 
  std::array<std::int64_t,3> _usedPartOfBrick(
      const std::array<std::int64_t,3>& size,
      const std::array<std::int64_t,3>& brickpos,
      std::int32_t lod);
 
  bool _isUsedPartOfBrickAllConstant(
      const std::shared_ptr<DataBuffer>& data,
      const std::array<std::int64_t,3>& brickpos,
      int32_t lod);
 
  static void _setPaddingToEdge(
      const std::shared_ptr<DataBuffer>& data,
      const std::array<std::int64_t,3>& used,
      int modulo, int dim);
 
  static void _setPaddingToConst(
      const std::shared_ptr<DataBuffer>& data,
      const std::array<std::int64_t,3>& used,
      double missingvalue, int dim);
 
  static void _setPaddingSamples(
      const std::shared_ptr<DataBuffer>& data,
      const std::array<std::int64_t,3>& used,
      double missingvalue, const compressor_t& compressor);
 
  void _writeWithRetry(
      rawdata_t rawdata,
      BrickStatus brickstatus,
      std::int64_t fileoffset,
      const std::array<std::int64_t,3>& brickpos,
      std::int32_t lod);
 
  void _writeOneNormalBrick(
      const std::shared_ptr<DataBuffer>& data,
      std::int64_t fileoffset,
      const std::array<std::int64_t,3>& brickpos,
      std::int32_t lod,
      const compressor_t& compressor);
 
  void _writeOneConstantBrick(
      const std::shared_ptr<DataBuffer>& data,
      const std::array<std::int64_t,3>& brickpos,
      std::int32_t lod);
 
  bool _mustLeakOldBrick(
      const std::shared_ptr<DataBuffer>& data,
      const compressor_t& compressor,
      BrickStatus brickstatus);
 
  void _writeOneBrick(
      const std::shared_ptr<DataBuffer>& data,
      const std::array<std::int64_t,3>& brickpos,
      std::int32_t lod,
      const compressor_t& compressor);
 
  void _writeAlignedRegion(
      const std::shared_ptr<DataBuffer>& data,
      const std::array<std::int64_t,3>& start,
      std::int32_t lod,
      const compressor_t& compressor);
};
 
} // namespace