Java tutorial
/** * 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.mapreduce.lib.join; import java.io.DataOutput; import java.io.DataInput; import java.io.IOException; import java.util.BitSet; import java.util.Iterator; import java.util.NoSuchElementException; import org.apache.hadoop.classification.InterfaceAudience; import org.apache.hadoop.classification.InterfaceStability; import org.apache.hadoop.io.NullWritable; import org.apache.hadoop.io.Text; import org.apache.hadoop.io.Writable; import org.apache.hadoop.io.WritableUtils; /** * Writable type storing multiple {@link org.apache.hadoop.io.Writable}s. * * This is *not* a general-purpose tuple type. In almost all cases, users are * encouraged to implement their own serializable types, which can perform * better validation and provide more efficient encodings than this class is * capable. TupleWritable relies on the join framework for type safety and * assumes its instances will rarely be persisted, assumptions not only * incompatible with, but contrary to the general case. * * @see org.apache.hadoop.io.Writable */ @InterfaceAudience.Public @InterfaceStability.Stable public class TupleWritable implements Writable, Iterable<Writable> { protected BitSet written; private Writable[] values; /** * Create an empty tuple with no allocated storage for writables. */ public TupleWritable() { written = new BitSet(0); } /** * Initialize tuple with storage; unknown whether any of them contain * "written" values. */ public TupleWritable(Writable[] vals) { written = new BitSet(vals.length); values = vals; } /** * Return true if tuple has an element at the position provided. */ public boolean has(int i) { return written.get(i); } /** * Get ith Writable from Tuple. */ public Writable get(int i) { return values[i]; } /** * The number of children in this Tuple. */ public int size() { return values.length; } /** * {@inheritDoc} */ public boolean equals(Object other) { if (other instanceof TupleWritable) { TupleWritable that = (TupleWritable) other; if (!this.written.equals(that.written)) { return false; } for (int i = 0; i < values.length; ++i) { if (!has(i)) continue; if (!values[i].equals(that.get(i))) { return false; } } return true; } return false; } public int hashCode() { assert false : "hashCode not designed"; return written.hashCode(); } /** * Return an iterator over the elements in this tuple. * Note that this doesn't flatten the tuple; one may receive tuples * from this iterator. */ public Iterator<Writable> iterator() { final TupleWritable t = this; return new Iterator<Writable>() { int bitIndex = written.nextSetBit(0); public boolean hasNext() { return bitIndex >= 0; } public Writable next() { int returnIndex = bitIndex; if (returnIndex < 0) throw new NoSuchElementException(); bitIndex = written.nextSetBit(bitIndex + 1); return t.get(returnIndex); } public void remove() { if (!written.get(bitIndex)) { throw new IllegalStateException("Attempt to remove non-existent val"); } written.clear(bitIndex); } }; } /** * Convert Tuple to String as in the following. * <tt>[<child1>,<child2>,...,<childn>]</tt> */ public String toString() { StringBuffer buf = new StringBuffer("["); for (int i = 0; i < values.length; ++i) { buf.append(has(i) ? values[i].toString() : ""); buf.append(","); } if (values.length != 0) buf.setCharAt(buf.length() - 1, ']'); else buf.append(']'); return buf.toString(); } // Writable /** Writes each Writable to <code>out</code>. * TupleWritable format: * {@code * <count><type1><type2>...<typen><obj1><obj2>...<objn> * } */ public void write(DataOutput out) throws IOException { WritableUtils.writeVInt(out, values.length); writeBitSet(out, values.length, written); for (int i = 0; i < values.length; ++i) { Text.writeString(out, values[i].getClass().getName()); } for (int i = 0; i < values.length; ++i) { if (has(i)) { values[i].write(out); } } } /** * {@inheritDoc} */ @SuppressWarnings("unchecked") // No static typeinfo on Tuples public void readFields(DataInput in) throws IOException { int card = WritableUtils.readVInt(in); values = new Writable[card]; readBitSet(in, card, written); Class<? extends Writable>[] cls = new Class[card]; try { for (int i = 0; i < card; ++i) { cls[i] = Class.forName(Text.readString(in)).asSubclass(Writable.class); } for (int i = 0; i < card; ++i) { if (cls[i].equals(NullWritable.class)) { values[i] = NullWritable.get(); } else { values[i] = cls[i].newInstance(); } if (has(i)) { values[i].readFields(in); } } } catch (ClassNotFoundException e) { throw new IOException("Failed tuple init", e); } catch (IllegalAccessException e) { throw new IOException("Failed tuple init", e); } catch (InstantiationException e) { throw new IOException("Failed tuple init", e); } } /** * Record that the tuple contains an element at the position provided. */ void setWritten(int i) { written.set(i); } /** * Record that the tuple does not contain an element at the position * provided. */ void clearWritten(int i) { written.clear(i); } /** * Clear any record of which writables have been written to, without * releasing storage. */ void clearWritten() { written.clear(); } /** * Writes the bit set to the stream. The first 64 bit-positions of the bit * set are written as a VLong for backwards-compatibility with older * versions of TupleWritable. All bit-positions >= 64 are encoded as a byte * for every 8 bit-positions. */ private static final void writeBitSet(DataOutput stream, int nbits, BitSet bitSet) throws IOException { long bits = 0L; int bitSetIndex = bitSet.nextSetBit(0); for (; bitSetIndex >= 0 && bitSetIndex < Long.SIZE; bitSetIndex = bitSet.nextSetBit(bitSetIndex + 1)) { bits |= 1L << bitSetIndex; } WritableUtils.writeVLong(stream, bits); if (nbits > Long.SIZE) { bits = 0L; for (int lastWordWritten = 0; bitSetIndex >= 0 && bitSetIndex < nbits; bitSetIndex = bitSet.nextSetBit(bitSetIndex + 1)) { int bitsIndex = bitSetIndex % Byte.SIZE; int word = (bitSetIndex - Long.SIZE) / Byte.SIZE; if (word > lastWordWritten) { stream.writeByte((byte) bits); bits = 0L; for (lastWordWritten++; lastWordWritten < word; lastWordWritten++) { stream.writeByte((byte) bits); } } bits |= 1L << bitsIndex; } stream.writeByte((byte) bits); } } /** * Reads a bitset from the stream that has been written with * {@link #writeBitSet(DataOutput, int, BitSet)}. */ private static final void readBitSet(DataInput stream, int nbits, BitSet bitSet) throws IOException { bitSet.clear(); long initialBits = WritableUtils.readVLong(stream); long last = 0L; while (0L != initialBits) { last = Long.lowestOneBit(initialBits); initialBits ^= last; bitSet.set(Long.numberOfTrailingZeros(last)); } for (int offset = Long.SIZE; offset < nbits; offset += Byte.SIZE) { byte bits = stream.readByte(); while (0 != bits) { last = Long.lowestOneBit(bits); bits ^= last; bitSet.set(Long.numberOfTrailingZeros(last) + offset); } } } }