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

网格计算

开发平台:

Java

  1. /**
  2.  * Licensed to the Apache Software Foundation (ASF) under one
  3.  * or more contributor license agreements.  See the NOTICE file
  4.  * distributed with this work for additional information
  5.  * regarding copyright ownership.  The ASF licenses this file
  6.  * to you under the Apache License, Version 2.0 (the
  7.  * "License"); you may not use this file except in compliance
  8.  * with the License.  You may obtain a copy of the License at
  9.  *
  10.  *     http://www.apache.org/licenses/LICENSE-2.0
  11.  *
  12.  * Unless required by applicable law or agreed to in writing, software
  13.  * distributed under the License is distributed on an "AS IS" BASIS,
  14.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15.  * See the License for the specific language governing permissions and
  16.  * limitations under the License.
  17.  */
  18. package org.apache.hadoop.hdfs.protocol;
  19. import java.io.*;
  20. import org.apache.hadoop.hdfs.server.common.GenerationStamp;
  21. import org.apache.hadoop.io.*;
  22. /**************************************************
  23.  * A Block is a Hadoop FS primitive, identified by a 
  24.  * long.
  25.  *
  26.  **************************************************/
  27. public class Block implements Writable, Comparable<Block> {
  28.   static {                                      // register a ctor
  29.     WritableFactories.setFactory
  30.       (Block.class,
  31.        new WritableFactory() {
  32.          public Writable newInstance() { return new Block(); }
  33.        });
  34.   }
  35.   // generation stamp of blocks that pre-date the introduction of
  36.   // a generation stamp.
  37.   public static final long GRANDFATHER_GENERATION_STAMP = 0;
  38.   /**
  39.    */
  40.   public static boolean isBlockFilename(File f) {
  41.     String name = f.getName();
  42.     if ( name.startsWith( "blk_" ) && 
  43.         name.indexOf( '.' ) < 0 ) {
  44.       return true;
  45.     } else {
  46.       return false;
  47.     }
  48.   }
  49.   static long filename2id(String name) {
  50.     return Long.parseLong(name.substring("blk_".length()));
  51.   }
  52.   private long blockId;
  53.   private long numBytes;
  54.   private long generationStamp;
  55.   public Block() {this(0, 0, 0);}
  56.   public Block(final long blkid, final long len, final long generationStamp) {
  57.     set(blkid, len, generationStamp);
  58.   }
  59.   public Block(final long blkid) {this(blkid, 0, GenerationStamp.WILDCARD_STAMP);}
  60.   public Block(Block blk) {this(blk.blockId, blk.numBytes, blk.generationStamp);}
  61.   /**
  62.    * Find the blockid from the given filename
  63.    */
  64.   public Block(File f, long len, long genstamp) {
  65.     this(filename2id(f.getName()), len, genstamp);
  66.   }
  67.   public void set(long blkid, long len, long genStamp) {
  68.     this.blockId = blkid;
  69.     this.numBytes = len;
  70.     this.generationStamp = genStamp;
  71.   }
  72.   /**
  73.    */
  74.   public long getBlockId() {
  75.     return blockId;
  76.   }
  77.   
  78.   public void setBlockId(long bid) {
  79.     blockId = bid;
  80.   }
  81.   /**
  82.    */
  83.   public String getBlockName() {
  84.     return "blk_" + String.valueOf(blockId);
  85.   }
  86.   /**
  87.    */
  88.   public long getNumBytes() {
  89.     return numBytes;
  90.   }
  91.   public void setNumBytes(long len) {
  92.     this.numBytes = len;
  93.   }
  94.   public long getGenerationStamp() {
  95.     return generationStamp;
  96.   }
  97.   
  98.   public void setGenerationStamp(long stamp) {
  99.     generationStamp = stamp;
  100.   }
  101.   /**
  102.    */
  103.   public String toString() {
  104.     return getBlockName() + "_" + getGenerationStamp();
  105.   }
  106.   /////////////////////////////////////
  107.   // Writable
  108.   /////////////////////////////////////
  109.   public void write(DataOutput out) throws IOException {
  110.     out.writeLong(blockId);
  111.     out.writeLong(numBytes);
  112.     out.writeLong(generationStamp);
  113.   }
  114.   public void readFields(DataInput in) throws IOException {
  115.     this.blockId = in.readLong();
  116.     this.numBytes = in.readLong();
  117.     this.generationStamp = in.readLong();
  118.     if (numBytes < 0) {
  119.       throw new IOException("Unexpected block size: " + numBytes);
  120.     }
  121.   }
  122.   /////////////////////////////////////
  123.   // Comparable
  124.   /////////////////////////////////////
  125.   static void validateGenerationStamp(long generationstamp) {
  126.     if (generationstamp == GenerationStamp.WILDCARD_STAMP) {
  127.       throw new IllegalStateException("generationStamp (=" + generationstamp
  128.           + ") == GenerationStamp.WILDCARD_STAMP");
  129.     }    
  130.   }
  131.   /** {@inheritDoc} */
  132.   public int compareTo(Block b) {
  133.     //Wildcard generationStamp is NOT ALLOWED here
  134.     validateGenerationStamp(this.generationStamp);
  135.     validateGenerationStamp(b.generationStamp);
  136.     if (blockId < b.blockId) {
  137.       return -1;
  138.     } else if (blockId == b.blockId) {
  139.       return GenerationStamp.compare(generationStamp, b.generationStamp);
  140.     } else {
  141.       return 1;
  142.     }
  143.   }
  144.   /** {@inheritDoc} */
  145.   public boolean equals(Object o) {
  146.     if (!(o instanceof Block)) {
  147.       return false;
  148.     }
  149.     final Block that = (Block)o;
  150.     //Wildcard generationStamp is ALLOWED here
  151.     return this.blockId == that.blockId
  152.       && GenerationStamp.equalsWithWildcard(
  153.           this.generationStamp, that.generationStamp);
  154.   }
  155.   /** {@inheritDoc} */
  156.   public int hashCode() {
  157.     //GenerationStamp is IRRELEVANT and should not be used here
  158.     return 37 * 17 + (int) (blockId^(blockId>>>32));
  159.   }
  160. }