kv__store_8h_source.html

#ifndef FASTLY_KV_STORE_H

#define FASTLY_KV_STORE_H

#include <chrono>

#include <fastly/detail/rust_iterator_range.h>

#include <fastly/error.h>

#include <fastly/http/body.h>

#include <fastly/sdk-sys.h>

#include <functional>

#include <optional>


namespace fastly::kv_store {

using fastly::sys::kv_store::KVStoreErrorCode;


class KVStoreError {

public:


  KVStoreError(fastly::sys::kv_store::KVStoreError *e)

      : err_(rust::Box<fastly::sys::kv_store::KVStoreError>::from_raw(e)) {};


  KVStoreError(rust::Box<fastly::sys::kv_store::KVStoreError> e)

      : err_(std::move(e)) {};


  KVStoreErrorCode error_code();

  std::string error_msg();


private:

  rust::Box<fastly::sys::kv_store::KVStoreError> err_;

};


template <class T = void> using expected = tl::expected<T, KVStoreError>;

template <class T = void> using unexpected = tl::unexpected<T>;


namespace detail {


template <class HandleType> class KVPendingHandle {

public:

  std::uint32_t as_u32() const { return handle_; }


  static HandleType from_u32(std::uint32_t handle) {

    return HandleType(handle);

  }


protected:

  explicit KVPendingHandle(std::uint32_t handle) : handle_(handle) {}

  std::uint32_t handle_;

};


} // namespace detail


struct PendingInsertHandle

    : public detail::KVPendingHandle<PendingInsertHandle> {

  using detail::KVPendingHandle<PendingInsertHandle>::KVPendingHandle;

};


struct PendingLookupHandle

    : public detail::KVPendingHandle<PendingLookupHandle> {

  using detail::KVPendingHandle<PendingLookupHandle>::KVPendingHandle;

};


struct PendingEraseHandle : public detail::KVPendingHandle<PendingEraseHandle> {

  using detail::KVPendingHandle<PendingEraseHandle>::KVPendingHandle;

};


struct PendingListHandle : public detail::KVPendingHandle<PendingListHandle> {

  using detail::KVPendingHandle<PendingListHandle>::KVPendingHandle;

};


class LookupBuilder;


class LookupResponse {

  friend LookupBuilder;


public:

  Body take_body();


  std::optional<Body> try_take_body();


  std::vector<uint8_t> take_body_bytes();


  std::optional<std::vector<std::uint8_t>> metadata() const;


  std::uint64_t current_generation() const;


private:

  friend class KVStore;

  LookupResponse(rust::Box<fastly::sys::kv_store::LookupResponse> response)

      : response_(std::move(response)) {}

  rust::Box<fastly::sys::kv_store::LookupResponse> response_;

};


class LookupBuilder {

public:

  expected<LookupResponse> execute(std::string_view key) const;


  expected<PendingLookupHandle> execute_async(std::string_view key) const;


private:

  friend class KVStore;

  LookupBuilder(rust::Box<fastly::sys::kv_store::LookupBuilder> builder)

      : builder_(std::move(builder)) {}

  rust::Box<fastly::sys::kv_store::LookupBuilder> builder_;

};


class EraseBuilder {

public:

  expected<> execute(std::string_view key) const;


  expected<PendingEraseHandle> execute_async(std::string_view key) const;


private:

  friend class KVStore;

  EraseBuilder(rust::Box<fastly::sys::kv_store::EraseBuilder> builder)

      : builder_(std::move(builder)) {}

  rust::Box<fastly::sys::kv_store::EraseBuilder> builder_;

};


using InsertMode = fastly::sys::kv_store::InsertMode;


class KVStore;


class InsertBuilder {

public:

  InsertBuilder mode(InsertMode mode) &&;


  InsertBuilder background_fetch() &&;


  InsertBuilder if_generation_match(std::uint64_t gen) &&;


  InsertBuilder metadata(const std::string &data) &&;


  InsertBuilder time_to_live(std::chrono::milliseconds ttl) &&;


  expected<> execute(const std::string &key, Body body) &&;


  expected<PendingInsertHandle> execute_async(const std::string &key,

                                              Body body) &&;


private:

  friend class KVStore;

  InsertBuilder(rust::Box<fastly::sys::kv_store::InsertBuilder> builder)

      : builder_(std::move(builder)) {}

  rust::Box<fastly::sys::kv_store::InsertBuilder> builder_;

};


struct ListModeStrong {};

struct ListModeEventual {};


struct ListModeOther {

  std::string other;

};


using ListMode = std::variant<ListModeStrong, ListModeEventual, ListModeOther>;


class ListResponse;

class KVStore;


class ListPage {

  friend ListResponse;

  friend KVStore;


public:

  std::vector<std::string> keys() const;

  std::vector<std::string> into_keys();


  std::optional<std::string> next_cursor() const;


  std::optional<std::string> prefix() const;


  std::uint32_t limit() const;


  ListMode mode() const;


private:

  friend class ListBuilder;

  ListPage(rust::Box<fastly::sys::kv_store::ListPage> page)

      : page_(std::move(page)) {}

  rust::Box<fastly::sys::kv_store::ListPage> page_;

};


class ListResponse : public fastly::detail::RustIteratorRange<

                         ListResponse, fastly::sys::kv_store::ListResponse> {

public:

  using fastly::detail::RustIteratorRange<

      ListResponse, fastly::sys::kv_store::ListResponse>::RustIteratorRange;


  std::optional<expected<ListPage>> next() {

    fastly::sys::kv_store::ListPage *page;

    fastly::sys::kv_store::KVStoreError *err;

    if (this->iter_->next(page, err)) {

      if (err == nullptr) {

        return ListPage(

            rust::Box<fastly::sys::kv_store::ListPage>::from_raw(page));

      } else {

        return unexpected(KVStoreError(

            rust::Box<fastly::sys::kv_store::KVStoreError>::from_raw(err)));

      }

    } else {

      return std::nullopt;

    }

  }


};


class ListBuilder {

public:

  ListBuilder eventual_consistency() &&;


  ListBuilder cursor(const std::string &cursor) &&;


  ListBuilder limit(std::uint32_t limit) &&;


  ListBuilder prefix(const std::string &prefix) &&;


  expected<ListPage> execute() &&;


  ListResponse iter() &&;


  expected<PendingListHandle> execute_async() const;


private:

  friend class KVStore;

  ListBuilder(rust::Box<fastly::sys::kv_store::ListBuilder> builder)

      : builder_(std::move(builder)) {}

  rust::Box<fastly::sys::kv_store::ListBuilder> builder_;

};


class KVStore {

public:

  static expected<std::optional<KVStore>> open(std::string_view name);

  expected<LookupResponse> lookup(std::string_view key) const;

  LookupBuilder build_lookup() const;


  expected<LookupResponse>

  pending_lookup_wait(PendingLookupHandle pending_request_handle) const;


  expected<> insert(std::string_view key, Body value) const;


  InsertBuilder build_insert() const;


  expected<>

  pending_insert_wait(PendingInsertHandle pending_insert_handle) const;


  expected<> erase(std::string_view key) const;


  EraseBuilder build_erase() const;


  expected<> pending_erase_wait(PendingEraseHandle pending_erase_handle) const;


  expected<ListPage> list() const;


  ListBuilder build_list() const;


  expected<ListPage>

  pending_list_wait(PendingListHandle pending_request_handle) const;


private:

  explicit KVStore(rust::Box<fastly::sys::kv_store::KVStore> store)

      : store_(std::move(store)) {}


  rust::Box<fastly::sys::kv_store::KVStore> store_;

};


} // namespace fastly::kv_store

#endif

body.h

fastly::detail::RustIteratorRange
Definition rust_iterator_range.h:14

fastly::detail::RustIteratorRange< ListResponse, fastly::sys::kv_store::ListResponse >::iter_
rust::Box< fastly::sys::kv_store::ListResponse > iter_
Definition rust_iterator_range.h:73

fastly::detail::RustIteratorRange< ListResponse, fastly::sys::kv_store::ListResponse >::RustIteratorRange
RustIteratorRange(rust::Box< fastly::sys::kv_store::ListResponse > iter)
Definition rust_iterator_range.h:16

fastly::http::Body
Definition body.h:42

fastly::kv_store::EraseBuilder
Definition kv_store.h:131

fastly::kv_store::EraseBuilder::execute
expected execute(std::string_view key) const
Execute the erasure and wait for the response.

fastly::kv_store::EraseBuilder::execute_async
expected< PendingEraseHandle > execute_async(std::string_view key) const
Execute the erasure asynchronously.

fastly::kv_store::EraseBuilder::KVStore
friend class KVStore
Definition kv_store.h:140

fastly::kv_store::InsertBuilder
Definition kv_store.h:149

fastly::kv_store::InsertBuilder::execute
expected execute(const std::string &key, Body body) &&

fastly::kv_store::InsertBuilder::execute_async
expected< PendingInsertHandle > execute_async(const std::string &key, Body body) &&
Initiate async insert of a value into the KV Store.

fastly::kv_store::InsertBuilder::background_fetch
InsertBuilder background_fetch() &&

fastly::kv_store::InsertBuilder::time_to_live
InsertBuilder time_to_live(std::chrono::milliseconds ttl) &&

fastly::kv_store::InsertBuilder::metadata
InsertBuilder metadata(const std::string &data) &&
Sets an arbitrary data field which can contain up to 2000B of data.

fastly::kv_store::InsertBuilder::if_generation_match
InsertBuilder if_generation_match(std::uint64_t gen) &&

fastly::kv_store::InsertBuilder::mode
InsertBuilder mode(InsertMode mode) &&
Change the behavior in the case when the new key matches an existing key.

fastly::kv_store::InsertBuilder::KVStore
friend class KVStore
Definition kv_store.h:182

fastly::kv_store::KVStoreError
Definition kv_store.h:13

fastly::kv_store::KVStoreError::KVStoreError
KVStoreError(fastly::sys::kv_store::KVStoreError *e)
Definition kv_store.h:15

fastly::kv_store::KVStoreError::error_msg
std::string error_msg()

fastly::kv_store::KVStoreError::KVStoreError
KVStoreError(rust::Box< fastly::sys::kv_store::KVStoreError > e)
Definition kv_store.h:17

fastly::kv_store::KVStoreError::error_code
KVStoreErrorCode error_code()

fastly::kv_store::KVStore
Definition kv_store.h:285

fastly::kv_store::KVStore::pending_list_wait
expected< ListPage > pending_list_wait(PendingListHandle pending_request_handle) const
Wait on a pending list operation.

fastly::kv_store::KVStore::open
static expected< std::optional< KVStore > > open(std::string_view name)

fastly::kv_store::KVStore::insert
expected insert(std::string_view key, Body value) const

fastly::kv_store::KVStore::build_list
ListBuilder build_list() const

fastly::kv_store::KVStore::build_insert
InsertBuilder build_insert() const

fastly::kv_store::KVStore::build_erase
EraseBuilder build_erase() const

fastly::kv_store::KVStore::pending_lookup_wait
expected< LookupResponse > pending_lookup_wait(PendingLookupHandle pending_request_handle) const
Look up a value in the KV Store.

fastly::kv_store::KVStore::pending_erase_wait
expected pending_erase_wait(PendingEraseHandle pending_erase_handle) const
Erase a value in the KV Store.

fastly::kv_store::KVStore::pending_insert_wait
expected pending_insert_wait(PendingInsertHandle pending_insert_handle) const
Insert a value in the KV Store.

fastly::kv_store::KVStore::lookup
expected< LookupResponse > lookup(std::string_view key) const

fastly::kv_store::KVStore::build_lookup
LookupBuilder build_lookup() const

fastly::kv_store::KVStore::erase
expected erase(std::string_view key) const
Erase a value in the KV Store.

fastly::kv_store::KVStore::list
expected< ListPage > list() const
List keys in the KV Store.

fastly::kv_store::ListBuilder
Definition kv_store.h:251

fastly::kv_store::ListBuilder::execute_async
expected< PendingListHandle > execute_async() const
Initiate async list of values in the KV Store.

fastly::kv_store::ListBuilder::execute
expected< ListPage > execute() &&
Initiate and wait on a list of values in the KV Store.

fastly::kv_store::ListBuilder::prefix
ListBuilder prefix(const std::string &prefix) &&
Set the prefix match for items to include in the resultset.

fastly::kv_store::ListBuilder::iter
ListResponse iter() &&

fastly::kv_store::ListBuilder::cursor
ListBuilder cursor(const std::string &cursor) &&
Change the cursor of the request.

fastly::kv_store::ListBuilder::limit
ListBuilder limit(std::uint32_t limit) &&
Set the maximum number of items included in the response.

fastly::kv_store::ListBuilder::KVStore
friend class KVStore
Definition kv_store.h:279

fastly::kv_store::ListBuilder::eventual_consistency
ListBuilder eventual_consistency() &&

fastly::kv_store::ListPage
Definition kv_store.h:197

fastly::kv_store::ListPage::limit
std::uint32_t limit() const
Returns the limit used in the List operation.

fastly::kv_store::ListPage::next_cursor
std::optional< std::string > next_cursor() const
Returns the next cursor of the List operation.

fastly::kv_store::ListPage::keys
std::vector< std::string > keys() const
Returns a vector of the listed keys in the current page.

fastly::kv_store::ListPage::mode
ListMode mode() const
Returns the mode used in the List operation.

fastly::kv_store::ListPage::prefix
std::optional< std::string > prefix() const
Returns the prefix used in the List operation.

fastly::kv_store::ListPage::into_keys
std::vector< std::string > into_keys()

fastly::kv_store::ListPage::ListBuilder
friend class ListBuilder
Definition kv_store.h:221

fastly::kv_store::ListResponse
Definition kv_store.h:228

fastly::kv_store::ListResponse::next
std::optional< expected< ListPage > > next()
Gets the next page of results.
Definition kv_store.h:234

fastly::kv_store::LookupBuilder
Definition kv_store.h:116

fastly::kv_store::LookupBuilder::execute
expected< LookupResponse > execute(std::string_view key) const
Execute the lookup and wait for the response.

fastly::kv_store::LookupBuilder::execute_async
expected< PendingLookupHandle > execute_async(std::string_view key) const
Execute the lookup asynchronously.

fastly::kv_store::LookupBuilder::KVStore
friend class KVStore
Definition kv_store.h:125

fastly::kv_store::LookupResponse::take_body
Body take_body()
Returns the body, making the LookupResponse bodyless.

fastly::kv_store::LookupResponse::metadata
std::optional< std::vector< std::uint8_t > > metadata() const
Reads the metadata of the KVStore item.

fastly::kv_store::LookupResponse::take_body_bytes
std::vector< uint8_t > take_body_bytes()

fastly::kv_store::LookupResponse::try_take_body
std::optional< Body > try_take_body()

fastly::kv_store::LookupResponse::current_generation
std::uint64_t current_generation() const
Reads the generation of the KVStore item.

fastly::kv_store::LookupResponse::KVStore
friend class KVStore
Definition kv_store.h:110

fastly::kv_store::detail::KVPendingHandle
Definition kv_store.h:29

fastly::kv_store::detail::KVPendingHandle::from_u32
static HandleType from_u32(std::uint32_t handle)
Definition kv_store.h:39

fastly::kv_store::detail::KVPendingHandle::KVPendingHandle
KVPendingHandle(std::uint32_t handle)
Definition kv_store.h:44

fastly::kv_store::detail::KVPendingHandle::handle_
std::uint32_t handle_
Definition kv_store.h:45

fastly::kv_store::detail::KVPendingHandle::as_u32
std::uint32_t as_u32() const
Definition kv_store.h:34

error.h

fastly::kv_store::detail
Definition kv_store.h:28

fastly::kv_store
Definition body.h:18

fastly::kv_store::InsertMode
fastly::sys::kv_store::InsertMode InsertMode
Definition kv_store.h:146

fastly::kv_store::unexpected
tl::unexpected< T > unexpected
Definition kv_store.h:26

fastly::kv_store::ListMode
std::variant< ListModeStrong, ListModeEventual, ListModeOther > ListMode
Definition kv_store.h:193

fastly::kv_store::expected
tl::expected< T, KVStoreError > expected
Definition kv_store.h:25

fastly
Definition backend.h:13

rust_iterator_range.h

fastly::kv_store::ListModeEventual
Definition kv_store.h:189

fastly::kv_store::ListModeOther
Definition kv_store.h:190

fastly::kv_store::ListModeOther::other
std::string other
Definition kv_store.h:191

fastly::kv_store::ListModeStrong
Definition kv_store.h:188

fastly::kv_store::PendingEraseHandle
Definition kv_store.h:75

fastly::kv_store::PendingInsertHandle
Definition kv_store.h:56

fastly::kv_store::PendingListHandle
Definition kv_store.h:83

fastly::kv_store::PendingLookupHandle
Definition kv_store.h:65