Apache
/
hbase
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

HBASE-1189 Changing the map type used internally for HbaseMapWritable 

git-svn-id: https://svn.apache.org/repos/asf/hadoop/hbase/trunk@748256 13f79535-47bb-0310-9956-ffa450edef68
This commit is contained in:
Michael Stack 2009-02-26 18:17:46 +00:00
parent 5a9bdffadb
commit e52b1ac411
3 changed files with 107 additions and 29 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
CHANGES.txt
View File

@ -61,6 +61,8 @@ Release 0.20.0 - Unreleased
(Lars George via Stack)
HBASE-1221 When using ant -projecthelp to build HBase not all the important
options show up (Erik Holstad via Stack)
HBASE-1189 Changing the map type used internally for HbaseMapWritable
(Erik Holstad via Stack)
Release 0.19.0 - 01/21/2009
INCOMPATIBLE CHANGES

71
src/java/org/apache/hadoop/hbase/io/CodeToClassAndBack.java Normal file
View File

@ -0,0 +1,71 @@
/**
* Copyright 2009 The Apache Software Foundation
*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you 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.
*/
package org.apache.hadoop.hbase.io;
import java.util.*;
/**
* A Static Interface.
* Instead of having this code in the the HbaseMapWritable code, where it
* blocks the possibility of altering the variables and changing their types,
* it is put here in this static interface where the static final Maps are
* loaded one time. Only byte[] and Cell are supported at this time.
*/
public interface CodeToClassAndBack {
/**
* Static map that contains mapping from code to class
*/
public static final Map<Byte, Class<?>> CODE_TO_CLASS =
new HashMap<Byte, Class<?>>();
/**
* Static map that contains mapping from class to code
*/
public static final Map<Class<?>, Byte> CLASS_TO_CODE =
new HashMap<Class<?>, Byte>();
/**
* Class list for supported classes
*/
public Class[] classList = {byte[].class, Cell.class};
/**
* The static loader that is used instead of the static constructor in
* HbaseMapWritable.
*/
public InternalStaticLoader sl =
new InternalStaticLoader(classList, CODE_TO_CLASS, CLASS_TO_CODE);
/**
* Class that loads the static maps with their values.
*/
public class InternalStaticLoader{
InternalStaticLoader(Class[] classList, Map<Byte, Class<?>> CODE_TO_CLASS,
Map<Class<?>, Byte> CLASS_TO_CODE){
byte code = 1;
for(int i=0; i<classList.length; i++){
CLASS_TO_CODE.put(classList[i], code);
CODE_TO_CLASS.put(code, classList[i]);
code++;
}
}
}
}

63
src/java/org/apache/hadoop/hbase/io/HbaseMapWritable.java
View File

@ -24,7 +24,6 @@ import java.io.DataOutput;
import java.io.IOException;
import java.util.Collection;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import java.util.SortedMap;
@ -33,9 +32,7 @@ import java.util.concurrent.atomic.AtomicReference;
import org.apache.hadoop.conf.Configurable;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.HStoreKey;
import org.apache.hadoop.hbase.util.Bytes;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.io.Writable;
import org.apache.hadoop.util.ReflectionUtils;
@ -48,37 +45,45 @@ import org.apache.hadoop.util.ReflectionUtils;
* @param <K> <byte []> key TODO: Parameter K is never used, could be removed.
* @param <V> value Expects a Writable or byte [].
*/
public class HbaseMapWritable <K, V>
implements SortedMap<byte [], V>, Writable, Configurable {
private AtomicReference<Configuration> conf =
new AtomicReference<Configuration>();
public class HbaseMapWritable <K,V>
implements SortedMap<byte[],V>, Configurable, Writable,
CodeToClassAndBack{
private AtomicReference<Configuration> conf = null;
protected SortedMap<byte [], V> instance = null;
// Static maps of code to class and vice versa. Includes types used in hbase
// only.
static final Map<Byte, Class<?>> CODE_TO_CLASS =
new HashMap<Byte, Class<?>>();
static final Map<Class<?>, Byte> CLASS_TO_CODE =
new HashMap<Class<?>, Byte>();
// only. These maps are now initialized in a static loader interface instead
// of in a static contructor for this class, this is done so that it is
// possible to have a regular contructor here, so that different params can
// be used.
// Removed the old types like Text from the maps, if needed to add more types
// this can be done in the StaticHBaseMapWritableLoader interface. Only
// byte[] and Cell are supported now.
// static final Map<Byte, Class<?>> CODE_TO_CLASS =
// new HashMap<Byte, Class<?>>();
// static final Map<Class<?>, Byte> CLASS_TO_CODE =
// new HashMap<Class<?>, Byte>();
static {
byte code = 0;
addToMap(HStoreKey.class, code++);
addToMap(ImmutableBytesWritable.class, code++);
addToMap(Text.class, code++);
addToMap(Cell.class, code++);
addToMap(byte [].class, code++);
}
/**
* The default contructor where a TreeMap is used
**/
public HbaseMapWritable(){
this (new TreeMap<byte [], V>(Bytes.BYTES_COMPARATOR));
}
@SuppressWarnings("boxing")
private static void addToMap(final Class<?> clazz,
final byte code) {
CLASS_TO_CODE.put(clazz, code);
CODE_TO_CLASS.put(code, clazz);
/**
* Contructor where another SortedMap can be used
*
* @param map the SortedMap to be used
**/
public HbaseMapWritable(SortedMap<byte[], V> map){
conf = new AtomicReference<Configuration>();
instance = map;
}
private SortedMap<byte [], V> instance =
new TreeMap<byte [], V>(Bytes.BYTES_COMPARATOR);
/** @return the conf */
public Configuration getConf() {
return conf.get();
@ -228,4 +233,4 @@ implements SortedMap<byte [], V>, Writable, Configurable {
this.instance.put(key, value);
}
}
}
}