KeyValueCache.h

/*
 * Copyright (C) 2019-2024 HERE Europe B.V.
 *
 * 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.
 *
 * SPDX-License-Identifier: Apache-2.0
 * License-Filename: LICENSE
 */
 
#pragma once
 
#include <ctime>
#include <functional>
#include <limits>
#include <memory>
#include <string>
#include <vector>
 
#include <olp/core/CoreApi.h>
#include <olp/core/client/ApiError.h>
#include <olp/core/client/ApiNoResult.h>
#include <olp/core/client/ApiResponse.h>
#include <olp/core/porting/any.h>
#include <olp/core/utils/WarningWorkarounds.h>
 
namespace olp {
namespace cache {
 
using Encoder = std::function<std::string()>;
using Decoder = std::function<olp::porting::any(const std::string&)>;
 
template <typename Result>
using OperationOutcome = client::ApiResponse<Result, client::ApiError>;
using OperationOutcomeEmpty = OperationOutcome<client::ApiNoResult>;
 
class CORE_API KeyValueCache {
 public:
  static constexpr time_t kDefaultExpiry = std::numeric_limits<time_t>::max();
 
  using ValueType = std::vector<unsigned char>;
 
  using ValueTypePtr = std::shared_ptr<ValueType>;
 
  using KeyListType = std::vector<std::string>;
 
  virtual ~KeyValueCache() = default;
 
  virtual bool Put(const std::string& key, const olp::porting::any& value,
                   const Encoder& encoder, time_t expiry = kDefaultExpiry) = 0;
 
  virtual bool Put(const std::string& key, const ValueTypePtr value,
                   time_t expiry = kDefaultExpiry) = 0;
 
  virtual olp::porting::any Get(const std::string& key,
                                const Decoder& encoder) = 0;
 
  virtual ValueTypePtr Get(const std::string& key) = 0;
 
  virtual bool Remove(const std::string& key) = 0;
 
  virtual bool RemoveKeysWithPrefix(const std::string& prefix) = 0;
 
  virtual bool Contains(const std::string& key) const {
    OLP_SDK_CORE_UNUSED(key);
    return false;
  }
 
  virtual bool Protect(const KeyListType& keys) {
    OLP_SDK_CORE_UNUSED(keys);
    return false;
  }
 
  virtual bool Release(const KeyListType& keys) {
    OLP_SDK_CORE_UNUSED(keys);
    return false;
  }
 
  virtual bool IsProtected(const std::string& key) const {
    OLP_SDK_CORE_UNUSED(key);
    return false;
  }
 
  virtual void Promote(const std::string& key) { OLP_SDK_CORE_UNUSED(key); }
 
  virtual OperationOutcome<ValueTypePtr> Read(const std::string& key) {
    OLP_SDK_CORE_UNUSED(key);
    return client::ApiError(client::ErrorCode::Unknown, "Not implemented");
  }
 
  virtual OperationOutcomeEmpty Write(const std::string& key,
                                      const ValueTypePtr& value,
                                      time_t expiry = kDefaultExpiry) {
    OLP_SDK_CORE_UNUSED(key);
    OLP_SDK_CORE_UNUSED(value);
    OLP_SDK_CORE_UNUSED(expiry);
    return client::ApiError(client::ErrorCode::Unknown, "Not implemented");
  }
 
  virtual OperationOutcomeEmpty Delete(const std::string& key) {
    OLP_SDK_CORE_UNUSED(key);
    return client::ApiError(client::ErrorCode::Unknown, "Not implemented");
  }
 
  virtual OperationOutcomeEmpty DeleteByPrefix(const std::string& prefix) {
    OLP_SDK_CORE_UNUSED(prefix);
    return client::ApiError(client::ErrorCode::Unknown, "Not implemented");
  }
 
  virtual OperationOutcome<KeyListType> ListKeysWithPrefix(
      const std::string& prefix) {
    OLP_SDK_CORE_UNUSED(prefix);
    return client::ApiError(client::ErrorCode::Unknown, "Not implemented");
  }
};
 
}  // namespace cache
}  // namespace olp