opendal.hpp

Go to the documentation of this file.

/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you 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 <optional>
#include <string>
#include <unordered_map>
#include <vector>
 
#include "boost/date_time/posix_time/ptime.hpp"
#include "boost/iostreams/concepts.hpp"
#include "boost/iostreams/stream.hpp"
 
namespace opendal {
 
namespace details {
class Operator;
class Reader;
class Lister;
}  // namespace details
 
enum class EntryMode : int {
  FILE = 1,
  DIR = 2,
  UNKNOWN = 0,
};
 
struct Metadata {
  EntryMode type;
  std::uint64_t content_length;
  std::optional<std::string> cache_control;
  std::optional<std::string> content_disposition;
  std::optional<std::string> content_md5;
  std::optional<std::string> content_type;
  std::optional<std::string> etag;
  std::optional<boost::posix_time::ptime> last_modified;
};
 
struct Entry {
  std::string path;
};
 
class Reader;
class Lister;
 
class Operator {
 public:
  Operator();
 
  Operator(std::string_view scheme,
           const std::unordered_map<std::string, std::string> &config = {});
 
  // Disable copy and assign
  Operator(const Operator &) = delete;
  Operator &operator=(const Operator &) = delete;
 
  // Enable move
  Operator(Operator &&);
  Operator &operator=(Operator &&);
 
  ~Operator();
 
  bool available() const;
 
  std::string read(std::string_view path);
 
  void write(std::string_view path, std::string_view data);
 
  Reader reader(std::string_view path);
 
  [[deprecated("Use exists() instead.")]]
  bool is_exist(std::string_view path);
 
  bool exists(std::string_view path);
 
  void create_dir(std::string_view path);
 
  void copy(std::string_view src, std::string_view dst);
 
  void rename(std::string_view src, std::string_view dst);
 
  void remove(std::string_view path);
 
  Metadata stat(std::string_view path);
 
  std::vector<Entry> list(std::string_view path);
 
  Lister lister(std::string_view path);
 
 private:
  std::unique_ptr<details::Operator> operator_;
};
 
class Reader
    : public boost::iostreams::device<boost::iostreams::input_seekable> {
 public:
  Reader(std::unique_ptr<details::Reader> &&reader);
 
  Reader(Reader &&);
 
  ~Reader();
 
  std::streamsize read(void *s, std::streamsize n);
 
  std::streampos seek(std::streamoff off, std::ios_base::seekdir way);
 
 private:
  std::unique_ptr<details::Reader> raw_reader_;
};
 
// Boost IOStreams requires it to be copyable. So we need to use
// `reference_wrapper` in ReaderStream. More details can be seen at
// https://lists.boost.org/Archives/boost/2005/10/95939.php
 
class ReaderStream
    : public boost::iostreams::stream<boost::reference_wrapper<Reader>> {
 public:
  ReaderStream(Reader &&reader)
      : boost::iostreams::stream<boost::reference_wrapper<Reader>>(
            boost::ref(reader_)),
        reader_(std::move(reader)) {}
 
 private:
  Reader reader_;
};
 
class Lister {
 public:
  Lister(std::unique_ptr<details::Lister> lister);
 
  Lister(Lister &&);
 
  ~Lister();
 
  class Iterator {
   public:
    using iterator_category = std::input_iterator_tag;
    using value_type = Entry;
    using difference_type = std::ptrdiff_t;
    using pointer = Entry *;
    using reference = Entry &;
 
    Iterator(Lister &lister) : lister_{lister} {
      current_entry_ = lister_.next();
    }
 
    Entry operator*() { return current_entry_.value(); }
 
    Iterator &operator++() {
      if (current_entry_) {
        current_entry_ = lister_.next();
      }
      return *this;
    }
 
    bool operator!=(const Iterator &other) const {
      return current_entry_ != std::nullopt ||
             other.current_entry_ != std::nullopt;
    }
 
   protected:
    // Only used for end iterator
    Iterator(Lister &lister, bool /*end*/) : lister_(lister) {}
 
   private:
    Lister &lister_;
    std::optional<Entry> current_entry_;
 
    friend class Lister;
  };
 
  std::optional<Entry> next();
 
  Iterator begin() { return Iterator(*this); }
  Iterator end() { return Iterator(*this, true); }
 
 private:
  std::unique_ptr<details::Lister> raw_lister_;
};
 
}  // namespace opendal