Key.java
上传用户:quxuerui
上传日期:2018-01-08
资源大小:41811k
文件大小:5k
源码类别:

网格计算

开发平台:

Java

  1. /**
  2.  *
  3.  * Copyright (c) 2005, European Commission project OneLab under contract 034819 (http://www.one-lab.org)
  4.  * All rights reserved.
  5.  * Redistribution and use in source and binary forms, with or 
  6.  * without modification, are permitted provided that the following 
  7.  * conditions are met:
  8.  *  - Redistributions of source code must retain the above copyright 
  9.  *    notice, this list of conditions and the following disclaimer.
  10.  *  - Redistributions in binary form must reproduce the above copyright 
  11.  *    notice, this list of conditions and the following disclaimer in 
  12.  *    the documentation and/or other materials provided with the distribution.
  13.  *  - Neither the name of the University Catholique de Louvain - UCL
  14.  *    nor the names of its contributors may be used to endorse or 
  15.  *    promote products derived from this software without specific prior 
  16.  *    written permission.
  17.  *    
  18.  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
  19.  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
  20.  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 
  21.  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE 
  22.  * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, 
  23.  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 
  24.  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 
  25.  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 
  26.  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 
  27.  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN 
  28.  * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 
  29.  * POSSIBILITY OF SUCH DAMAGE.
  30.  */
  31. /**
  32.  * Licensed to the Apache Software Foundation (ASF) under one
  33.  * or more contributor license agreements.  See the NOTICE file
  34.  * distributed with this work for additional information
  35.  * regarding copyright ownership.  The ASF licenses this file
  36.  * to you under the Apache License, Version 2.0 (the
  37.  * "License"); you may not use this file except in compliance
  38.  * with the License.  You may obtain a copy of the License at
  39.  *
  40.  *     http://www.apache.org/licenses/LICENSE-2.0
  41.  *
  42.  * Unless required by applicable law or agreed to in writing, software
  43.  * distributed under the License is distributed on an "AS IS" BASIS,
  44.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  45.  * See the License for the specific language governing permissions and
  46.  * limitations under the License.
  47.  */
  48. package org.apache.hadoop.util.bloom;
  49. import java.io.DataInput;
  50. import java.io.DataOutput;
  51. import java.io.IOException;
  52. import org.apache.hadoop.io.WritableComparable;
  53. /**
  54.  * The general behavior of a key that must be stored in a filter.
  55.  * 
  56.  * @see Filter The general behavior of a filter
  57.  */
  58. public class Key implements WritableComparable<Key> {
  59.   /** Byte value of key */
  60.   byte[] bytes;
  61.   
  62.   /**
  63.    * The weight associated to <i>this</i> key.
  64.    * <p>
  65.    * <b>Invariant</b>: if it is not specified, each instance of 
  66.    * <code>Key</code> will have a default weight of 1.0
  67.    */
  68.   double weight;
  69.   /** default constructor - use with readFields */
  70.   public Key() {}
  71.   /**
  72.    * Constructor.
  73.    * <p>
  74.    * Builds a key with a default weight.
  75.    * @param value The byte value of <i>this</i> key.
  76.    */
  77.   public Key(byte[] value) {
  78.     this(value, 1.0);
  79.   }
  80.   /**
  81.    * Constructor.
  82.    * <p>
  83.    * Builds a key with a specified weight.
  84.    * @param value The value of <i>this</i> key.
  85.    * @param weight The weight associated to <i>this</i> key.
  86.    */
  87.   public Key(byte[] value, double weight) {
  88.     set(value, weight);
  89.   }
  90.   /**
  91.    * @param value
  92.    * @param weight
  93.    */
  94.   public void set(byte[] value, double weight) {
  95.     if (value == null) {
  96.       throw new IllegalArgumentException("value can not be null");
  97.     }
  98.     this.bytes = value;
  99.     this.weight = weight;
  100.   }
  101.   
  102.   /** @return byte[] The value of <i>this</i> key. */
  103.   public byte[] getBytes() {
  104.     return this.bytes;
  105.   }
  106.   /** @return Returns the weight associated to <i>this</i> key. */
  107.   public double getWeight() {
  108.     return weight;
  109.   }
  110.   /**
  111.    * Increments the weight of <i>this</i> key with a specified value. 
  112.    * @param weight The increment.
  113.    */
  114.   public void incrementWeight(double weight) {
  115.     this.weight += weight;
  116.   }
  117.   /** Increments the weight of <i>this</i> key by one. */
  118.   public void incrementWeight() {
  119.     this.weight++;
  120.   }
  121.   @Override
  122.   public boolean equals(Object o) {
  123.     if (!(o instanceof Key)) {
  124.       return false;
  125.     }
  126.     return this.compareTo((Key)o) == 0;
  127.   }
  128.   
  129.   @Override
  130.   public int hashCode() {
  131.     int result = 0;
  132.     for (int i = 0; i < bytes.length; i++) {
  133.       result ^= Byte.valueOf(bytes[i]).hashCode();
  134.     }
  135.     result ^= Double.valueOf(weight).hashCode();
  136.     return result;
  137.   }
  138.   // Writable
  139.   public void write(DataOutput out) throws IOException {
  140.     out.writeInt(bytes.length);
  141.     out.write(bytes);
  142.     out.writeDouble(weight);
  143.   }
  144.   
  145.   public void readFields(DataInput in) throws IOException {
  146.     this.bytes = new byte[in.readInt()];
  147.     in.readFully(this.bytes);
  148.     weight = in.readDouble();
  149.   }
  150.   
  151.   // Comparable
  152.   
  153.   public int compareTo(Key other) {
  154.     int result = this.bytes.length - other.getBytes().length;
  155.     for (int i = 0; result == 0 && i < bytes.length; i++) {
  156.       result = this.bytes[i] - other.bytes[i];
  157.     }
  158.     
  159.     if (result == 0) {
  160.       result = Double.valueOf(this.weight - other.weight).intValue();
  161.     }
  162.     return result;
  163.   }
  164. }