1 /**
2 * Copyright 2010 The Apache Software Foundation
3 *
4 * Licensed to the Apache Software Foundation (ASF) under one
5 * or more contributor license agreements. See the NOTICE file
6 * distributed with this work for additional information
7 * regarding copyright ownership. The ASF licenses this file
8 * to you under the Apache License, Version 2.0 (the
9 * "License"); you may not use this file except in compliance
10 * with the License. You may obtain a copy of the License at
11 *
12 * http://www.apache.org/licenses/LICENSE-2.0
13 *
14 * Unless required by applicable law or agreed to in writing, software
15 * distributed under the License is distributed on an "AS IS" BASIS,
16 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
17 * See the License for the specific language governing permissions and
18 * limitations under the License.
19 */
20
21 package org.apache.hadoop.hbase.util;
22
23 import org.apache.hadoop.conf.Configuration;
24
25 /**
26 * This class represents a common API for hashing functions.
27 */
28 public abstract class Hash {
29 /** Constant to denote invalid hash type. */
30 public static final int INVALID_HASH = -1;
31 /** Constant to denote {@link JenkinsHash}. */
32 public static final int JENKINS_HASH = 0;
33 /** Constant to denote {@link MurmurHash}. */
34 public static final int MURMUR_HASH = 1;
35
36 /**
37 * This utility method converts String representation of hash function name
38 * to a symbolic constant. Currently two function types are supported,
39 * "jenkins" and "murmur".
40 * @param name hash function name
41 * @return one of the predefined constants
42 */
43 public static int parseHashType(String name) {
44 if ("jenkins".equalsIgnoreCase(name)) {
45 return JENKINS_HASH;
46 } else if ("murmur".equalsIgnoreCase(name)) {
47 return MURMUR_HASH;
48 } else {
49 return INVALID_HASH;
50 }
51 }
52
53 /**
54 * This utility method converts the name of the configured
55 * hash type to a symbolic constant.
56 * @param conf configuration
57 * @return one of the predefined constants
58 */
59 public static int getHashType(Configuration conf) {
60 String name = conf.get("hbase.hash.type", "murmur");
61 return parseHashType(name);
62 }
63
64 /**
65 * Get a singleton instance of hash function of a given type.
66 * @param type predefined hash type
67 * @return hash function instance, or null if type is invalid
68 */
69 public static Hash getInstance(int type) {
70 switch(type) {
71 case JENKINS_HASH:
72 return JenkinsHash.getInstance();
73 case MURMUR_HASH:
74 return MurmurHash.getInstance();
75 default:
76 return null;
77 }
78 }
79
80 /**
81 * Get a singleton instance of hash function of a type
82 * defined in the configuration.
83 * @param conf current configuration
84 * @return defined hash type, or null if type is invalid
85 */
86 public static Hash getInstance(Configuration conf) {
87 int type = getHashType(conf);
88 return getInstance(type);
89 }
90
91 /**
92 * Calculate a hash using all bytes from the input argument, and
93 * a seed of -1.
94 * @param bytes input bytes
95 * @return hash value
96 */
97 public int hash(byte[] bytes) {
98 return hash(bytes, bytes.length, -1);
99 }
100
101 /**
102 * Calculate a hash using all bytes from the input argument,
103 * and a provided seed value.
104 * @param bytes input bytes
105 * @param initval seed value
106 * @return hash value
107 */
108 public int hash(byte[] bytes, int initval) {
109 return hash(bytes, 0, bytes.length, initval);
110 }
111
112 /**
113 * Calculate a hash using bytes from 0 to <code>length</code>, and
114 * the provided seed value
115 * @param bytes input bytes
116 * @param length length of the valid bytes after offset to consider
117 * @param initval seed value
118 * @return hash value
119 */
120 public int hash(byte[] bytes, int length, int initval) {
121 return hash(bytes, 0, length, initval);
122 }
123
124 /**
125 * Calculate a hash using bytes from 0 to <code>length</code>, and
126 * the provided seed value
127 * @param bytes input bytes
128 * @param offset the offset into the array to start consideration
129 * @param length length of the valid bytes after offset to consider
130 * @param initval seed value
131 * @return hash value
132 */
133 public abstract int hash(byte[] bytes, int offset, int length, int initval);
134 }