file.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 <cstdint>
#include <vector>
#include <string>
#include <memory>
#include <functional>
 
#include "../declspec.h"
#include "timer.h"
 
namespace OpenZGY {
  class IOContext;
}
 
namespace InternalZGY {
#if 0
}
#endif
 
enum class OpenMode
{
  Closed = 0,
  ReadOnly,
  ReadWrite,
  Truncate,
};
 
enum class UsageHint
{
  Unknown    = 0x00,
  TextFile   = 0x01,
  Header     = 0x10,
  Data       = 0x20,
  Compressed = 0x40,
  Mixed      = 0x40,
};
 
 
class Config
{
public:
  virtual ~Config();
  virtual std::string dump() const = 0;
 
protected:
  static std::string _get_string_env(
      const std::string& value_from_cf,
      const std::string& cfname,
      const std::string& envname,
      const std::string& dflt);
 
  static std::int64_t _get_numeric_env(
      std::int64_t value_from_cf,
      const std::string& cfname,
      const std::string& envname,
      std::int64_t dflt,
      std::int64_t min_value,
      std::int64_t max_value);
 
  static std::string _redact(const std::string&);
};
 
class FileConfig : public Config
{
public:
  explicit FileConfig(const OpenZGY::IOContext *context);
  virtual std::string dump() const override;
};
 
class ReadRequest
{
public:
  typedef std::function<void(const void*, std::int64_t)> delivery_t;
  std::int64_t offset;
  std::int64_t size;
  delivery_t delivery;
  ReadRequest(std::int64_t offset_in, std::int64_t size_in, const delivery_t& delivery_in)
    : offset(offset_in)
    , size(size_in)
    , delivery(delivery_in)
  {
  }
};
 
typedef std::vector<ReadRequest> ReadList;
typedef std::vector<ReadList> ReadDoubleList;
 
class FileADT
{
public:
  virtual ~FileADT();
 
  virtual void xx_read(void *data, std::int64_t offset, std::int64_t size, UsageHint usagehint=UsageHint::Unknown) = 0;
 
  virtual void xx_readv(const ReadList& requests, bool parallel_ok=false, bool immutable_ok=false, bool transient_ok=false, UsageHint usagehint=UsageHint::Unknown) = 0;
 
  virtual void xx_write(const void* data, std::int64_t offset, std::int64_t size, UsageHint usagehint=UsageHint::Unknown) = 0;
 
  virtual void xx_close() = 0;
 
  virtual std::int64_t xx_eof() const = 0;
 
  virtual bool xx_threadsafe() const = 0;
 
  virtual bool xx_iscloud() const = 0;
 
protected:
  static std::string _nice(std::int64_t n);
  static void _validate_read(void *data, std::int64_t offset, std::int64_t size, std::int64_t eof, OpenMode mode);
  static void _validate_write(const void *data, std::int64_t offset, std::int64_t size, OpenMode mode);
  static void _validate_readv(const ReadList& requests, std::int64_t eof, OpenMode mode);
 
public:
  static std::shared_ptr<FileADT> factory(const std::string& filename, OpenMode mode, const OpenZGY::IOContext *iocontext);
};
 
class OPENZGY_TEST_API FileFactory
{
public:
  typedef std::function<std::shared_ptr<FileADT>(const std::string&, OpenMode, const OpenZGY::IOContext*)> factory_t;
 
public:
  std::shared_ptr<FileADT> create(const std::string& filename, OpenMode mode, const OpenZGY::IOContext *iocontext);
  void add_factory(const factory_t& factory);
  static FileFactory& instance();
 
private:
  FileFactory();
  FileFactory(const FileFactory&) = delete;
  FileFactory& operator=(const FileFactory&) = delete;
 
private:
  std::vector<factory_t> _registry;
};
 
class FileCommon : public FileADT
{
protected:
  FileConfig _config;
  OpenMode _mode;
  std::string _name;
  std::int64_t _eof;
  std::shared_ptr<SummaryTimer> _rtimer;
  std::shared_ptr<SummaryTimer> _wtimer;
 
public:
  FileCommon(const std::string& filename, OpenMode mode, const OpenZGY::IOContext *iocontext);
  // NEW functions
  virtual std::int64_t _real_eof() const;
  virtual void _check_short_read(std::int64_t offset, std::int64_t size, std::int64_t got) const;
};
 
}