YugabyteDB (2.13.0.0-b42, bfc6a6643e7399ac8a0e81d06a3ee6d6571b33ab)

// Copyright (c) 2011-present, Facebook, Inc.  All rights reserved.

// This source code is licensed under the BSD-style license found in the

// LICENSE file in the root directory of this source tree. An additional grant

// of patent rights can be found in the PATENTS file in the same directory.

// Copyright (c) 2011 The LevelDB Authors. All rights reserved.

// Use of this source code is governed by a BSD-style license that can be

// found in the LICENSE file. See the AUTHORS file for names of contributors.

//

// The following only applies to changes made to this file as part of YugaByte development.

//

// Portions Copyright (c) YugaByte, Inc.

//

// 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 YB_ROCKSDB_COMPARATOR_H

#define YB_ROCKSDB_COMPARATOR_H

#include <memory>

#include <string>

#include "yb/util/slice.h"

namespace rocksdb {

// A Comparator object provides a total order across slices that are

// used as keys in an sstable or a database.  A Comparator implementation

// must be thread-safe since rocksdb may invoke its methods concurrently

// from multiple threads.

class Comparator {

 public:

  virtual ~Comparator();

  // Three-way comparison.  Returns value:

  //   < 0 iff "a" < "b",

  //   == 0 iff "a" == "b",

  //   > 0 iff "a" > "b"

  virtual int Compare(const Slice& a, const Slice& b) const = 0;

  // Compares two slices for equality. The following invariant should always

  // hold (and is the default implementation):

  //   Equal(a, b) iff Compare(a, b) == 0

  // Overwrite only if equality comparisons can be done more efficiently than

  // three-way comparisons.

  virtual bool Equal(const Slice& a, const Slice& b) const {

    return Compare(a, b) == 0;

  }

  // The name of the comparator.  Used to check for comparator

  // mismatches (i.e., a DB created with one comparator is

  // accessed using a different comparator.

  //

  // The client of this package should switch to a new name whenever

  // the comparator implementation changes in a way that will cause

  // the relative ordering of any two keys to change.

  //

  // Names starting with "rocksdb." are reserved and should not be used

  // by any clients of this package.

  virtual const char* Name() const = 0;

  // Advanced functions: these are used to reduce the space requirements

  // for internal data structures like index blocks.

  // If *start < limit, changes *start to a short string in [start,limit).

  // Simple comparator implementations may return with *start unchanged,

  // i.e., an implementation of this method that does nothing is correct.

  virtual void FindShortestSeparator(

      std::string* start,

      const Slice& limit) const = 0;

  // Changes *key to a short string >= *key.

  // Simple comparator implementations may return with *key unchanged,

  // i.e., an implementation of this method that does nothing is correct.

  virtual void FindShortSuccessor(std::string* key) const = 0;

};

typedef std::shared_ptr<const Comparator> ComparatorPtr;

// Return a builtin comparator that uses lexicographic byte-wise

// ordering.  The result remains the property of this module and

// must not be deleted.

extern const Comparator* BytewiseComparator();

extern const ComparatorPtr& SharedBytewiseComparator();

// Return a builtin comparator that uses reverse lexicographic byte-wise

// ordering.

extern const Comparator* ReverseBytewiseComparator();

// Returns a user key comparator that can be used for comparing two uint64_t

// slices. Instead of comparing slices byte-wise, it compares all the 8 bytes

// at once. Assumes same endian-ness is used though the database's lifetime.

// Symantics of comparison would differ from Bytewise comparator in little

// endian machines.

extern const Comparator* Uint64Comparator();

}  // namespace rocksdb

#endif // YB_ROCKSDB_COMPARATOR_H