keys.h

Go to the documentation of this file.

// Copyright 2019 Google LLC
//
// 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.

#ifndef GOOGLE_CLOUD_CPP_GOOGLE_CLOUD_SPANNER_KEYS_H
#define GOOGLE_CLOUD_CPP_GOOGLE_CLOUD_SPANNER_KEYS_H

#include "google/cloud/spanner/value.h"
#include "google/cloud/spanner/version.h"
#include <google/spanner/v1/keys.pb.h>
#include <string>
#include <utility>
#include <vector>

namespace google {
namespace cloud {
namespace spanner {
inline namespace SPANNER_CLIENT_NS {

using Key = std::vector<Value>;

template <typename... Ts>
Key MakeKey(Ts&&... ts) {
  return Key{Value(std::forward<Ts>(ts))...};
}

class KeyBound {
 public:
  enum class Bound { kClosed, kOpen };

  KeyBound() = delete;

  KeyBound(Key key, Bound bound) : key_(std::move(key)), bound_(bound) {}

  KeyBound(KeyBound const&) = default;
  KeyBound& operator=(KeyBound const&) = default;
  KeyBound(KeyBound&&) = default;
  KeyBound& operator=(KeyBound&&) = default;

  Key const& key() const& { return key_; }

  Key&& key() && { return std::move(key_); }

  Bound bound() const { return bound_; }

  friend bool operator==(KeyBound const& a, KeyBound const& b);
  friend bool operator!=(KeyBound const& a, KeyBound const& b) {
    return !(a == b);
  }

 private:
  Key key_;
  Bound bound_;
};

template <typename... Ts>
KeyBound MakeKeyBoundClosed(Ts&&... ts) {
  return KeyBound(MakeKey(std::forward<Ts>(ts)...), KeyBound::Bound::kClosed);
}

template <typename... Ts>
KeyBound MakeKeyBoundOpen(Ts&&... ts) {
  return KeyBound(MakeKey(std::forward<Ts>(ts)...), KeyBound::Bound::kOpen);
}

class KeySet;
namespace internal {
::google::spanner::v1::KeySet ToProto(KeySet);
KeySet FromProto(::google::spanner::v1::KeySet);
}  // namespace internal

class KeySet {
 public:
  static KeySet All() {
    KeySet ks;
    ks.proto_.set_all(true);
    return ks;
  }

  KeySet() = default;

  // Copy and move constructors and assignment operators.
  KeySet(KeySet const&) = default;
  KeySet& operator=(KeySet const&) = default;
  KeySet(KeySet&&) = default;
  KeySet& operator=(KeySet&&) = default;

  KeySet& AddKey(Key key);

  KeySet& AddRange(KeyBound start, KeyBound end);

  friend bool operator==(KeySet const& a, KeySet const& b);
  friend bool operator!=(KeySet const& a, KeySet const& b) { return !(a == b); }

 private:
  friend ::google::spanner::v1::KeySet internal::ToProto(KeySet);
  friend KeySet internal::FromProto(::google::spanner::v1::KeySet);
  explicit KeySet(google::spanner::v1::KeySet proto)
      : proto_(std::move(proto)) {}

  google::spanner::v1::KeySet proto_;
};

}  // namespace SPANNER_CLIENT_NS
}  // namespace spanner
}  // namespace cloud
}  // namespace google

#endif  // GOOGLE_CLOUD_CPP_GOOGLE_CLOUD_SPANNER_KEYS_H