## Uses of Interface
org.apache.hadoop.io.WritableComparable

Packages that use WritableComparable
org.apache.hadoop.contrib.index.mapred
org.apache.hadoop.examples: Hadoop example code.
org.apache.hadoop.examples.dancing: This package is a distributed implementation of Knuth's dancing links algorithm that can run under Hadoop.
org.apache.hadoop.io: Generic i/o code for use when reading and writing data to the network, to databases, and to files.
org.apache.hadoop.mapred: A software framework for easily writing applications which process vast amounts of data (multi-terabyte data-sets) parallelly on large clusters (thousands of nodes) built of commodity hardware in a reliable, fault-tolerant manner.
org.apache.hadoop.mapred.join: Given a set of sorted datasets keyed with the same class and yielding equal partitions, it is possible to effect a join of those datasets prior to the map.
org.apache.hadoop.mapred.lib: Library of generally useful mappers, reducers, and partitioners.
org.apache.hadoop.mapred.lib.aggregate: Classes for performing various counting and aggregations.
org.apache.hadoop.mapreduce
org.apache.hadoop.record: Hadoop record I/O contains classes and a record description language translator for simplifying serialization and deserialization of records in a language-neutral manner.
org.apache.hadoop.record.meta
org.apache.hadoop.util.bloom

Uses of WritableComparable in org.apache.hadoop.contrib.index.mapred

Classes in org.apache.hadoop.contrib.index.mapred with type parameters of type WritableComparable
`interface` `ILocalAnalysis<K extends WritableComparable,V extends Writable>` Application specific local analysis.
`class` `IndexUpdateMapper<K extends WritableComparable,V extends Writable>` This class applies local analysis on a key-value pair and then convert the result docid-operation pair to a shard-and-intermediate form pair.

Classes in org.apache.hadoop.contrib.index.mapred that implement WritableComparable
`class` `DocumentID` The class represents a document id, which is of type text.
`class` `Shard` This class represents the metadata of a shard.

Methods in org.apache.hadoop.contrib.index.mapred that return types with arguments of type WritableComparable
`static Class<? extends WritableComparable>` `IndexUpdateMapper.getMapOutputKeyClass()` Get the map output key class.
`static Class<? extends WritableComparable>` `IndexUpdateReducer.getOutputKeyClass()` Get the reduce output key class.

Uses of WritableComparable in org.apache.hadoop.examples

Classes in org.apache.hadoop.examples that implement WritableComparable
`static class` `MultiFileWordCount.WordOffset` This record keeps <filename,offset> pairs.
`static class` `SecondarySort.IntPair` Define a pair of integers that are writable.

Method parameters in org.apache.hadoop.examples with type arguments of type WritableComparable
`void` `PiEstimator.PiReducer.reduce(BooleanWritable isInside, Iterator<LongWritable> values, OutputCollector<WritableComparable<?>,Writable> output, Reporter reporter)` Accumulate number of points inside/outside results from the mappers.

Uses of WritableComparable in org.apache.hadoop.examples.dancing

Methods in org.apache.hadoop.examples.dancing with parameters of type WritableComparable
`void` `DistributedPentomino.PentMap.map(WritableComparable key, Text value, OutputCollector<Text,Text> output, Reporter reporter)` Break the prefix string into moves (a sequence of integer row ids that will be selected for each column in order).

Uses of WritableComparable in org.apache.hadoop.io

Classes in org.apache.hadoop.io that implement WritableComparable
`class` `BooleanWritable` A WritableComparable for booleans.
`class` `BytesWritable` A byte sequence that is usable as a key or value.
`class` `ByteWritable` A WritableComparable for a single byte.
`class` `DoubleWritable` Writable for Double values.
`class` `FloatWritable` A WritableComparable for floats.
`class` `IntWritable` A WritableComparable for ints.
`class` `LongWritable` A WritableComparable for longs.
`class` `MD5Hash` A Writable for MD5 hash values.
`class` `NullWritable` Singleton Writable with no data.
`class` `Text` This class stores text using standard UTF8 encoding.
`class` `UTF8` Deprecated. replaced by Text
`class` `VIntWritable` A WritableComparable for integer values stored in variable-length format.
`class` `VLongWritable` A WritableComparable for longs in a variable-length format.

Methods in org.apache.hadoop.io that return WritableComparable
`WritableComparable` `SortedMapWritable.firstKey()`
`WritableComparable` `SetFile.Reader.get(WritableComparable key)` Read the matching key from a set into `key`.
`WritableComparable` `MapFile.Reader.getClosest(WritableComparable key, Writable val)` Finds the record that is the closest match to the specified key.
`WritableComparable` `MapFile.Reader.getClosest(WritableComparable key, Writable val, boolean before)` Finds the record that is the closest match to the specified key.
`WritableComparable` `SortedMapWritable.lastKey()`
`WritableComparable` `MapFile.Reader.midKey()` Get the key at approximately the middle of the file.
`WritableComparable` `WritableComparator.newKey()` Construct a new `WritableComparable` instance.

Methods in org.apache.hadoop.io that return types with arguments of type WritableComparable
`Comparator<? super WritableComparable>` `SortedMapWritable.comparator()`
`Set<Map.Entry<WritableComparable,Writable>>` `SortedMapWritable.entrySet()`
`Class<? extends WritableComparable>` `WritableComparator.getKeyClass()` Returns the WritableComparable implementation class.
`SortedMap<WritableComparable,Writable>` `SortedMapWritable.headMap(WritableComparable toKey)`
`Set<WritableComparable>` `SortedMapWritable.keySet()`
`SortedMap<WritableComparable,Writable>` `SortedMapWritable.subMap(WritableComparable fromKey, WritableComparable toKey)`
`SortedMap<WritableComparable,Writable>` `SortedMapWritable.tailMap(WritableComparable fromKey)`

Methods in org.apache.hadoop.io with parameters of type WritableComparable
`void` `SetFile.Writer.append(WritableComparable key)` Append a key to a set.
`void` `BloomMapFile.Writer.append(WritableComparable key, Writable val)`
`void` `MapFile.Writer.append(WritableComparable key, Writable val)` Append a key/value pair to the map.
`int` `WritableComparator.compare(WritableComparable a, WritableComparable b)` Compare two WritableComparables.
`int` `WritableComparator.compare(WritableComparable a, WritableComparable b)` Compare two WritableComparables.
`int` `LongWritable.DecreasingComparator.compare(WritableComparable a, WritableComparable b)`
`int` `LongWritable.DecreasingComparator.compare(WritableComparable a, WritableComparable b)`
`void` `MapFile.Reader.finalKey(WritableComparable key)` Reads the final key from the file.
`WritableComparable` `SetFile.Reader.get(WritableComparable key)` Read the matching key from a set into `key`.
`Writable` `BloomMapFile.Reader.get(WritableComparable key, Writable val)` Fast version of the `MapFile.Reader.get(WritableComparable, Writable)` method.
`Writable` `MapFile.Reader.get(WritableComparable key, Writable val)` Return the value for the named key, or null if none exists.
`WritableComparable` `MapFile.Reader.getClosest(WritableComparable key, Writable val)` Finds the record that is the closest match to the specified key.
`WritableComparable` `MapFile.Reader.getClosest(WritableComparable key, Writable val, boolean before)` Finds the record that is the closest match to the specified key.
`SortedMap<WritableComparable,Writable>` `SortedMapWritable.headMap(WritableComparable toKey)`
`boolean` `SetFile.Reader.next(WritableComparable key)` Read the next key in a set into `key`.
`boolean` `MapFile.Reader.next(WritableComparable key, Writable val)` Read the next key/value pair in the map into `key` and `val`.
`boolean` `BloomMapFile.Reader.probablyHasKey(WritableComparable key)` Checks if this MapFile has the indicated key.
`Writable` `SortedMapWritable.put(WritableComparable key, Writable value)`
`boolean` `MapFile.Reader.seek(WritableComparable key)` Positions the reader at the named key, or if none such exists, at the first entry after the named key.
`boolean` `SetFile.Reader.seek(WritableComparable key)`
`SortedMap<WritableComparable,Writable>` `SortedMapWritable.subMap(WritableComparable fromKey, WritableComparable toKey)`
`SortedMap<WritableComparable,Writable>` `SortedMapWritable.subMap(WritableComparable fromKey, WritableComparable toKey)`
`SortedMap<WritableComparable,Writable>` `SortedMapWritable.tailMap(WritableComparable fromKey)`

Method parameters in org.apache.hadoop.io with type arguments of type WritableComparable
`static WritableComparator` `WritableComparator.get(Class<? extends WritableComparable> c)` Get a comparator for a `WritableComparable` implementation.
`void` `SortedMapWritable.putAll(Map<? extends WritableComparable,? extends Writable> t)`

Constructor parameters in org.apache.hadoop.io with type arguments of type WritableComparable
`BloomMapFile.Writer(Configuration conf, FileSystem fs, String dirName, Class<? extends WritableComparable> keyClass, Class valClass)`
`BloomMapFile.Writer(Configuration conf, FileSystem fs, String dirName, Class<? extends WritableComparable> keyClass, Class<? extends Writable> valClass, SequenceFile.CompressionType compress, CompressionCodec codec, Progressable progress)`
`BloomMapFile.Writer(Configuration conf, FileSystem fs, String dirName, Class<? extends WritableComparable> keyClass, Class valClass, SequenceFile.CompressionType compress)`
`BloomMapFile.Writer(Configuration conf, FileSystem fs, String dirName, Class<? extends WritableComparable> keyClass, Class valClass, SequenceFile.CompressionType compress, Progressable progress)`
`MapFile.Writer(Configuration conf, FileSystem fs, String dirName, Class<? extends WritableComparable> keyClass, Class valClass)` Create the named map for keys of the named class.
`MapFile.Writer(Configuration conf, FileSystem fs, String dirName, Class<? extends WritableComparable> keyClass, Class valClass, SequenceFile.CompressionType compress)` Create the named map for keys of the named class.
`MapFile.Writer(Configuration conf, FileSystem fs, String dirName, Class<? extends WritableComparable> keyClass, Class valClass, SequenceFile.CompressionType compress, CompressionCodec codec, Progressable progress)` Create the named map for keys of the named class.
`MapFile.Writer(Configuration conf, FileSystem fs, String dirName, Class<? extends WritableComparable> keyClass, Class valClass, SequenceFile.CompressionType compress, Progressable progress)` Create the named map for keys of the named class.
`SequenceFile.Sorter(FileSystem fs, Class<? extends WritableComparable> keyClass, Class valClass, Configuration conf)` Sort and merge files containing the named classes.
`SetFile.Writer(Configuration conf, FileSystem fs, String dirName, Class<? extends WritableComparable> keyClass, SequenceFile.CompressionType compress)` Create a set naming the element class and compression type.
`SetFile.Writer(FileSystem fs, String dirName, Class<? extends WritableComparable> keyClass)` Deprecated. pass a Configuration too
`WritableComparator(Class<? extends WritableComparable> keyClass)` Construct for a `WritableComparable` implementation.
`WritableComparator(Class<? extends WritableComparable> keyClass, boolean createInstances)`

Uses of WritableComparable in org.apache.hadoop.mapred

Methods in org.apache.hadoop.mapred with type parameters of type WritableComparable

`static

`<K extends WritableComparable,V extends Writable> Writable`

`

`MapFileOutputFormat.getEntry(MapFile.Reader[] readers, Partitioner<K,V> partitioner, K key, V value)`
Get an entry from output generated by this class.

Methods in org.apache.hadoop.mapred that return types with arguments of type WritableComparable
`RecordWriter<WritableComparable,Writable>` `MapFileOutputFormat.getRecordWriter(FileSystem ignored, JobConf job, String name, Progressable progress)`
`static Class<? extends WritableComparable>` `SequenceFileAsBinaryOutputFormat.getSequenceFileOutputKeyClass(JobConf conf)` Get the key class for the `SequenceFile`

Uses of WritableComparable in org.apache.hadoop.mapred.join

Classes in org.apache.hadoop.mapred.join with type parameters of type WritableComparable
`interface` `ComposableInputFormat<K extends WritableComparable,V extends Writable>` Refinement of InputFormat requiring implementors to provide ComposableRecordReader instead of RecordReader.
`interface` `ComposableRecordReader<K extends WritableComparable,V extends Writable>` Additional operations required of a RecordReader to participate in a join.
`class` `CompositeInputFormat<K extends WritableComparable>` An InputFormat capable of performing joins over a set of data sources sorted and partitioned the same way.
`class` `CompositeRecordReader<K extends WritableComparable,V extends Writable,X extends Writable>` A RecordReader that can effect joins of RecordReaders sharing a common key type and partitioning.
`class` `InnerJoinRecordReader<K extends WritableComparable>` Full inner join.
`class` `JoinRecordReader<K extends WritableComparable>` Base class for Composite joins returning Tuples of arbitrary Writables.
`class` `MultiFilterRecordReader<K extends WritableComparable,V extends Writable>` Base class for Composite join returning values derived from multiple sources, but generally not tuples.
`class` `OuterJoinRecordReader<K extends WritableComparable>` Full outer join.
`class` `OverrideRecordReader<K extends WritableComparable,V extends Writable>` Prefer the "rightmost" data source for this key.
`class` `WrappedRecordReader<K extends WritableComparable,U extends Writable>` Proxy class for a RecordReader participating in the join framework.

Uses of WritableComparable in org.apache.hadoop.mapred.lib

Classes in org.apache.hadoop.mapred.lib with type parameters of type WritableComparable
`class` `TotalOrderPartitioner<K extends WritableComparable,V>` Partitioner effecting a total order by reading split points from an externally generated source.

Methods in org.apache.hadoop.mapred.lib that return types with arguments of type WritableComparable
`static Class<? extends WritableComparable>` `MultipleOutputs.getNamedOutputKeyClass(JobConf conf, String namedOutput)` Returns the key class for a named output.

Uses of WritableComparable in org.apache.hadoop.mapred.lib.aggregate

Classes in org.apache.hadoop.mapred.lib.aggregate with type parameters of type WritableComparable
`class` `ValueAggregatorCombiner<K1 extends WritableComparable,V1 extends Writable>` This class implements the generic combiner of Aggregate.
`class` `ValueAggregatorJobBase<K1 extends WritableComparable,V1 extends Writable>` This abstract class implements some common functionalities of the the generic mapper, reducer and combiner classes of Aggregate.
`class` `ValueAggregatorMapper<K1 extends WritableComparable,V1 extends Writable>` This class implements the generic mapper of Aggregate.
`class` `ValueAggregatorReducer<K1 extends WritableComparable,V1 extends Writable>` This class implements the generic reducer of Aggregate.

Uses of WritableComparable in org.apache.hadoop.mapreduce

Classes in org.apache.hadoop.mapreduce that implement WritableComparable
`class` `ID` A general identifier, which internally stores the id as an integer.
`class` `JobID` JobID represents the immutable and unique identifier for the job.
`class` `TaskAttemptID` TaskAttemptID represents the immutable and unique identifier for a task attempt.
`class` `TaskID` TaskID represents the immutable and unique identifier for a Map or Reduce Task.

Uses of WritableComparable in org.apache.hadoop.record

Classes in org.apache.hadoop.record that implement WritableComparable
`class` `Record` Abstract class that is extended by generated classes.

Constructor parameters in org.apache.hadoop.record with type arguments of type WritableComparable
`RecordComparator(Class<? extends WritableComparable> recordClass)` Construct a raw `Record` comparison implementation.

Uses of WritableComparable in org.apache.hadoop.record.meta

Classes in org.apache.hadoop.record.meta that implement WritableComparable
`class` `RecordTypeInfo` A record's Type Information object which can read/write itself.

Uses of WritableComparable in org.apache.hadoop.util.bloom

Classes in org.apache.hadoop.util.bloom that implement WritableComparable
`class` `Key` The general behavior of a key that must be stored in a filter.

Copyright © 2009 The Apache Software Foundation