file_relay.h 2.25 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
// Copyright 2017-2021, 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 "file.h"

namespace InternalZGY {
#if 0
}
#endif

/**
 * Static class for (in some situation) speeding up read from cloud.
 */

/**
 * \brief A FileADT that forwards all requests to another instance.
 *
 * \details
 * This class is meant to be extended to add special handling of some
 * of FileADT members. Used by itself it is a no-op. The class is
 * typically used when just a few methods are to be intercepted and
 * it makes sense to have a default that just passes on the call.
 */
class FileRelay : public FileADT
{
private:
  std::shared_ptr<FileADT> _relay;
  FileRelay(const FileRelay&) = delete;
  FileRelay& operator=(const FileRelay&) = delete;

protected:
  const FileADT& relay() const { return *_relay; };
  FileADT& relay() { return *_relay; };

public:
  explicit FileRelay(std::shared_ptr<FileADT> relay);
  virtual ~FileRelay();
  virtual void         xx_read(void *data, std::int64_t offset, std::int64_t size, UsageHint hint) override {
    _relay->xx_read(data, offset, size, hint);
  }
  virtual void         xx_readv(const ReadList& requests, bool parallel_ok, bool immutable_ok, bool transient_ok, UsageHint hint) override {
    _relay->xx_readv(requests, parallel_ok, immutable_ok, transient_ok, hint);
  }
  virtual void         xx_write(const void* data, std::int64_t offset, std::int64_t size, UsageHint hint) override {
    _relay->xx_write(data, offset, size, hint);
  }
  virtual void         xx_close()         override {
    _relay->xx_close();
  }
  virtual std::int64_t xx_eof()     const override {
    return _relay->xx_eof();
  }
  virtual bool         xx_iscloud() const override {
    return _relay->xx_iscloud();
  }
};

} // namespace