From e52b1ac4117c0adf1f958c2698a934477ecb199d Mon Sep 17 00:00:00 2001 From: Michael Stack Date: Thu, 26 Feb 2009 18:17:46 +0000 Subject: [PATCH] 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 --- CHANGES.txt | 2 + .../hadoop/hbase/io/CodeToClassAndBack.java | 71 +++++++++++++++++++ .../hadoop/hbase/io/HbaseMapWritable.java | 63 ++++++++-------- 3 files changed, 107 insertions(+), 29 deletions(-) create mode 100644 src/java/org/apache/hadoop/hbase/io/CodeToClassAndBack.java diff --git a/CHANGES.txt b/CHANGES.txt index 52453601c68..36870458345 100644 --- a/CHANGES.txt +++ b/CHANGES.txt @@ -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 diff --git a/src/java/org/apache/hadoop/hbase/io/CodeToClassAndBack.java b/src/java/org/apache/hadoop/hbase/io/CodeToClassAndBack.java new file mode 100644 index 00000000000..a9997a54edc --- /dev/null +++ b/src/java/org/apache/hadoop/hbase/io/CodeToClassAndBack.java @@ -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> CODE_TO_CLASS = + new HashMap>(); + + /** + * Static map that contains mapping from class to code + */ + public static final Map, Byte> CLASS_TO_CODE = + new HashMap, 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> CODE_TO_CLASS, + Map, Byte> CLASS_TO_CODE){ + byte code = 1; + for(int i=0; i key TODO: Parameter K is never used, could be removed. * @param value Expects a Writable or byte []. */ -public class HbaseMapWritable -implements SortedMap, Writable, Configurable { - private AtomicReference conf = - new AtomicReference(); +public class HbaseMapWritable +implements SortedMap, Configurable, Writable, + CodeToClassAndBack{ + + private AtomicReference conf = null; + protected SortedMap instance = null; // Static maps of code to class and vice versa. Includes types used in hbase - // only. - static final Map> CODE_TO_CLASS = - new HashMap>(); - static final Map, Byte> CLASS_TO_CODE = - new HashMap, 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> CODE_TO_CLASS = + // new HashMap>(); + // static final Map, Byte> CLASS_TO_CODE = + // new HashMap, 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(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 map){ + conf = new AtomicReference(); + instance = map; } - private SortedMap instance = - new TreeMap(Bytes.BYTES_COMPARATOR); - + /** @return the conf */ public Configuration getConf() { return conf.get(); @@ -228,4 +233,4 @@ implements SortedMap, Writable, Configurable { this.instance.put(key, value); } } -} \ No newline at end of file +}