Index.h

/*
 * Copyright (C) 2019-2023 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 <map>
#include <memory>
#include <string>
#include <utility>
 
#include <olp/core/porting/optional.h>
#include <olp/dataservice/write/DataServiceWriteApi.h>
 
namespace olp {
namespace dataservice {
namespace write {
namespace model {
 
typedef std::string IndexName;
 
enum class DATASERVICE_WRITE_API IndexType {
  String,
 
  Int,
 
  Bool,
 
  Heretile,
 
  TimeWindow,
 
  Unsupported
};
 
class DATASERVICE_WRITE_API IndexValue {
 public:
  explicit IndexValue(IndexType type) : indexType_(type) {}
 
  IndexValue(const IndexValue&) = default;
 
  IndexValue(IndexValue&&) = default;
 
  IndexValue& operator=(IndexValue&&) = default;
 
  IndexValue& operator=(const IndexValue&) = default;
 
  virtual ~IndexValue() = default;
 
  IndexType getIndexType() const { return indexType_; }
 
 private:
  IndexType indexType_{IndexType::Unsupported};
};
 
class DATASERVICE_WRITE_API UnsupportedIndexValue final : public IndexValue {
 public:
  explicit UnsupportedIndexValue(IndexType type) : IndexValue(type) {}
};
 
class DATASERVICE_WRITE_API BooleanIndexValue final : public IndexValue {
  bool booleanValue_{false};
 
 public:
  BooleanIndexValue(bool booleanValue, IndexType type) : IndexValue(type) {
    booleanValue_ = std::move(booleanValue);
  }
 
  const bool& GetValue() const { return booleanValue_; }
 
  bool& GetMutableValue() { return booleanValue_; }
 
  void SetValue(const bool& value) { this->booleanValue_ = value; }
};
 
class DATASERVICE_WRITE_API IntIndexValue final : public IndexValue {
  int64_t intValue_{0};
 
 public:
  IntIndexValue(int64_t intValue, IndexType type) : IndexValue(type) {
    intValue_ = std::move(intValue);
  }
 
  const int64_t& GetValue() const { return intValue_; }
 
  int64_t& GetMutableValue() { return intValue_; }
 
  void SetValue(const int64_t& value) { this->intValue_ = value; }
};
 
class DATASERVICE_WRITE_API StringIndexValue final : public IndexValue {
  std::string stringValue_;
 
 public:
  StringIndexValue(std::string stringValue, IndexType type)
      : IndexValue(type), stringValue_{std::move(stringValue)} {}
 
  std::string GetValue() const { return stringValue_; }
 
  std::string& GetMutableValue() { return stringValue_; }
 
  void SetValue(const std::string& value) { this->stringValue_ = value; }
};
 
class DATASERVICE_WRITE_API TimeWindowIndexValue final : public IndexValue {
  int64_t timeWindowValue_{0};
 
 public:
  TimeWindowIndexValue(int64_t timeWindowValue, IndexType type)
      : IndexValue(type), timeWindowValue_{std::move(timeWindowValue)} {}
 
  const int64_t& GetValue() const { return timeWindowValue_; }
 
  int64_t& GetMutableValue() { return timeWindowValue_; }
 
  void SetValue(const int64_t& value) { this->timeWindowValue_ = value; }
};
 
class DATASERVICE_WRITE_API HereTileIndexValue final : public IndexValue {
  int64_t hereTileValue_{0};
 
 public:
  HereTileIndexValue(int64_t hereTileValue, IndexType type)
      : IndexValue(type), hereTileValue_{std::move(hereTileValue)} {}
 
  const int64_t& GetValue() const { return hereTileValue_; }
 
  int64_t& GetMutableValue() { return hereTileValue_; }
 
  void SetValue(const int64_t& value) { this->hereTileValue_ = value; }
};
 
class DATASERVICE_WRITE_API EmptyIndexValue final : public IndexValue {
 public:
  explicit EmptyIndexValue(IndexType type) : IndexValue(type) {}
};
 
class DATASERVICE_WRITE_API Index final {
 public:
  Index() = default;
 
  Index(std::string uuid,
        std::map<IndexName, std::shared_ptr<IndexValue>> indexFields)
      : id_(std::move(uuid)), indexFields_(std::move(indexFields)) {}
 
 private:
  porting::optional<std::string> checksum_;
  porting::optional<std::map<std::string, std::string>> metadata_;
  porting::optional<int64_t> size_;
  std::string id_;
  std::map<IndexName, std::shared_ptr<IndexValue>> indexFields_;
 
 public:
  const porting::optional<std::string>& GetCheckSum() const {
    return checksum_;
  }
 
  porting::optional<std::string>& GetMutableCheckSum() { return checksum_; }
 
  void SetCheckSum(const std::string& value) { this->checksum_ = value; }
 
  const porting::optional<std::map<std::string, std::string>>& GetMetadata()
      const {
    return metadata_;
  }
 
  porting::optional<std::map<std::string, std::string>>& GetMutableMetadata() {
    return metadata_;
  }
 
  void SetMetadata(const std::map<std::string, std::string>& value) {
    this->metadata_ = value;
  }
 
  const std::string& GetId() const { return id_; }
 
  std::string& GetMutableId() { return id_; }
 
  void SetId(const std::string& value) { this->id_ = value; }
 
  const std::map<IndexName, std::shared_ptr<IndexValue>>& GetIndexFields()
      const {
    return indexFields_;
  }
 
  std::map<IndexName, std::shared_ptr<IndexValue>>& GetMutableIndexFields() {
    return indexFields_;
  }
 
  void SetIndexFields(
      const std::map<IndexName, std::shared_ptr<IndexValue>>& value) {
    this->indexFields_ = value;
  }
 
  const porting::optional<int64_t>& GetSize() const { return size_; }
 
  porting::optional<int64_t>& GetMutableSize() { return size_; }
 
  void SetSize(const int64_t& value) { this->size_ = value; }
};
 
}  // namespace model
}  // namespace write
}  // namespace dataservice
}  // namespace olp