YugabyteDB (2.13.0.0-b42, bfc6a6643e7399ac8a0e81d06a3ee6d6571b33ab)

// Copyright 2011 Google Inc. All Rights Reserved.

//

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

//

// This is a library of legacy hashing routines. These routines are still in

// use, but are not encouraged for any new code, and may be removed at some

// point in the future.

//

// New code should use one of the targeted libraries that provide hash

// interfaces for the types needed. See //util/hash/README for details.

#ifndef YB_GUTIL_HASH_LEGACY_HASH_H

#define YB_GUTIL_HASH_LEGACY_HASH_H

#include "yb/gutil/hash/builtin_type_hash.h"

#include "yb/gutil/hash/jenkins.h"

#include "yb/gutil/integral_types.h"

// Hash8, Hash16 and Hash32 are for legacy use only.

typedef uint32 Hash32;

typedef uint16 Hash16;

typedef uint8 Hash8;

const Hash32 kIllegalHash32 = static_cast<Hash32>(0xffffffffUL);

const Hash16 kIllegalHash16 = static_cast<Hash16>(0xffff);

static const uint32 MIX32 = 0x12b9b0a1UL;           // pi; an arbitrary number

static const uint64 MIX64 = GG_ULONGLONG(0x2b992ddfa23249d6);  // more of pi

// ----------------------------------------------------------------------

// HashTo32()

// HashTo16()

//    These functions take various types of input (through operator

//    overloading) and return 32 or 16 bit quantities, respectively.

//    The basic rule of our hashing is: always mix().  Thus, even for

//    char outputs we cast to a uint32 and mix with two arbitrary numbers.

//    HashTo32 never returns kIllegalHash32, and similary,

//    HashTo16 never returns kIllegalHash16.

//

// Note that these methods avoid returning certain reserved values, while

// the corresponding HashXXStringWithSeed() methods may return any value.

// ----------------------------------------------------------------------

// This macro defines the HashTo32 and HashTo16 versions all in one go.

// It takes the argument list and a command that hashes your number.

// (For 16 we just mod retval before returning it.)  Example:

//    HASH_TO((char c), Hash32NumWithSeed(c, MIX32_1))

// evaluates to

//    uint32 retval;

//    retval = Hash32NumWithSeed(c, MIX32_1);

//    return retval == kIllegalHash32 ? retval-1 : retval;

//

#define HASH_TO(arglist, command)                              \

inline uint32 HashTo32 arglist {                               \

  uint32 retval = command;                                     \

  return retval == kIllegalHash32 ? retval-1 : retval;         \

}

Unexecuted instantiation: _Z8HashTo32PKwm

Unexecuted instantiation: _Z8HashTo32c

Unexecuted instantiation: _Z8HashTo32a

Unexecuted instantiation: _Z8HashTo32t

Unexecuted instantiation: _Z8HashTo32s

Unexecuted instantiation: _Z8HashTo32j

Unexecuted instantiation: _Z8HashTo32i

Unexecuted instantiation: _Z8HashTo32y

Unexecuted instantiation: _Z8HashTo32x

_Z8HashTo32PKcm

Line

Count

Source

67

70.1M

inline uint32 HashTo32 arglist {                               \

68

70.1M

  uint32 retval = command;                                     \

69

70.1M

  return retval == kIllegalHash32 ? retval-1 : retval;         \

70

70.1M

}

// This defines:

// HashToXX(char *s, int slen);

// HashToXX(char c);

// etc

HASH_TO((const char *s, size_t slen), Hash32StringWithSeed(s, slen, MIX32))

HASH_TO((const wchar_t *s, size_t slen),

        Hash32StringWithSeed(reinterpret_cast<const char*>(s),

                             sizeof(wchar_t) * slen,

                             MIX32))

HASH_TO((char c),  Hash32NumWithSeed(static_cast<uint32>(c), MIX32))

HASH_TO((schar c),  Hash32NumWithSeed(static_cast<uint32>(c), MIX32))

HASH_TO((uint16 c), Hash32NumWithSeed(static_cast<uint32>(c), MIX32))

HASH_TO((int16 c),  Hash32NumWithSeed(static_cast<uint32>(c), MIX32))

HASH_TO((uint32 c), Hash32NumWithSeed(static_cast<uint32>(c), MIX32))

HASH_TO((int32 c),  Hash32NumWithSeed(static_cast<uint32>(c), MIX32))

HASH_TO((uint64 c), static_cast<uint32>(Hash64NumWithSeed(c, MIX64) >> 32))

HASH_TO((int64 c),  static_cast<uint32>(Hash64NumWithSeed(c, MIX64) >> 32))

#undef HASH_TO        // clean up the macro space

inline uint16 HashTo16(const char *s, uint64 slen) {

  uint16 retval = Hash32StringWithSeed(s, slen, MIX32) >> 16;

  return retval == kIllegalHash16 ? static_cast<uint16>(retval-1) : retval;

}

#endif  // YB_GUTIL_HASH_LEGACY_HASH_H