iocontext.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.
 
#include "declspec.h"
#include "exception.h"
 
#include <cstdint>
#include <string>
#include <vector>
#include <functional>
 
namespace Test
{
  class TestIOContext;
}
namespace InternalZGY
{
  class SeismicStoreFile;
  class SeismicStoreFileDelayedWrite;
}
 
namespace OpenZGY {
#if 0
}
#endif
 
class OPENZGY_API IOContext
{
public:
  virtual ~IOContext();
  virtual std::string toString() const = 0;
};
 
class OPENZGY_API SeismicStoreIOContext : public IOContext
{
  // Needed because there are no public accessors. Because I am lazy.
  friend class Test::TestIOContext;
  friend class InternalZGY::SeismicStoreFile;
  friend class InternalZGY::SeismicStoreFileDelayedWrite;
 
public:
  typedef std::function<std::string()> tokencb_t;
  typedef std::function<void(const std::string&, std::int64_t, std::int64_t, std::int64_t, const std::vector<std::int64_t>&)> debugtrace_t;
  virtual std::string toString() const override;
  SeismicStoreIOContext();
 
private:
  std::string  _sdurl;
  std::string  _sdapikey;
  std::string  _sdtoken;
  std::string  _sdtokentype;
  std::int64_t _maxsize;
  std::int64_t _maxhole;
  std::int64_t _aligned;
  std::int64_t _segsize;
  std::int64_t _threads;
  std::string  _legaltag;
  std::string  _writeid;
  std::string  _seismicmeta;
  std::string  _sdtoken_cbtype;
  tokencb_t    _sdtokencb;
  debugtrace_t _debug_trace;
 
public:
  SeismicStoreIOContext& sdurl(const std::string& value)
  {
    this->_sdurl = value;
    return *this;
  }
 
  SeismicStoreIOContext& sdapikey(const std::string& value)
  {
    this->_sdapikey = value;
    return *this;
  }
 
  SeismicStoreIOContext& sdtoken(const std::string& value, const std::string& type) {
    this->_sdtoken = value;
    this->_sdtokentype = type;
    this->_sdtokencb = tokencb_t();
    return *this;
  }
 
  SeismicStoreIOContext& sdtokencb(const tokencb_t& value, const std::string& type) {
    this->_sdtokencb = value;
    this->_sdtokentype = type;
    this->_sdtoken = std::string();
    return *this;
  }
 
  SeismicStoreIOContext& maxsize(int value)
  {
    if (value < 0 || value > 1024)
      throw OpenZGY::Errors::ZgyUserError("maxsize must be between 0 and 1024 MB");
    this->_maxsize = value * (std::int64_t)(1024*1024);
    return *this;
  }
 
  SeismicStoreIOContext& maxhole(int value)
  {
    if (value < 0 || value > 1024)
      throw OpenZGY::Errors::ZgyUserError("maxhole must be between 0 and 1024 MB");
    this->_maxhole = value * (std::int64_t)(1024*1024);
    return *this;
  }
 
  SeismicStoreIOContext& aligned(int value)
  {
    if (value < 0 || value > 1024)
      throw OpenZGY::Errors::ZgyUserError("aligned must be between 0 and 1024 MB");
    this->_aligned = value * (std::int64_t)(1024*1024);
    return *this;
  }
 
  SeismicStoreIOContext& segsize(int value)
  {
    if (value < 0 || value > 16*1024)
      throw OpenZGY::Errors::ZgyUserError("segsize must be between 0 and 16*1024 MB");
    this->_segsize = value * (std::int64_t)(1024*1024);
    return *this;
  }
 
  SeismicStoreIOContext& threads(int value)
  {
    if (value < 1 || value > 1024)
      throw OpenZGY::Errors::ZgyUserError("threads must be between 1 and 1024");
    this->_threads = value;
    return *this;
  }
 
  SeismicStoreIOContext& legaltag(const std::string& value)
  {
    this->_legaltag = value;
    return *this;
  }
 
  SeismicStoreIOContext& writeid(const std::string& value)
  {
    this->_writeid = value;
    return *this;
  }
 
  SeismicStoreIOContext& seismicmeta(const std::string& value)
  {
    this->_seismicmeta = value;
    return *this;
  }
 
  SeismicStoreIOContext& debug_trace(const debugtrace_t& value)
  {
    this->_debug_trace = value;
    return *this;
  }
};
 
}
 
// namespace