Uses of Interface
org.apache.hadoop.io.Writable

Packages that use Writable
org.apache.hadoop.contrib.utils.join   
org.apache.hadoop.dfs A distributed implementation of FileSystem
org.apache.hadoop.examples Hadoop example code. 
org.apache.hadoop.fs An abstract file system API. 
org.apache.hadoop.hbase Provides HBase, the Hadoop simple database. 
org.apache.hadoop.hbase.filter   
org.apache.hadoop.hbase.io   
org.apache.hadoop.hbase.mapred   
org.apache.hadoop.hbase.util   
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.ipc Tools to help define network clients and servers. 
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.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.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.streaming Hadoop Streaming is a utility which allows users to create and run Map-Reduce jobs with any executables (e.g. 
org.onelab.filter   
 

Uses of Writable in org.apache.hadoop.contrib.utils.join
 

Classes in org.apache.hadoop.contrib.utils.join that implement Writable
 class TaggedMapOutput
          This abstract class serves as the base class for the values that flow from the mappers to the reducers in a data join job.
 

Methods in org.apache.hadoop.contrib.utils.join that return Writable
abstract  Writable TaggedMapOutput.getData()
           
 

Methods in org.apache.hadoop.contrib.utils.join with parameters of type Writable
protected abstract  TaggedMapOutput DataJoinMapperBase.generateTaggedMapOutput(Writable value)
          Generate a tagged map output value.
 void DataJoinReducerBase.map(WritableComparable arg0, Writable arg1, OutputCollector arg2, Reporter arg3)
           
 void DataJoinMapperBase.map(WritableComparable key, Writable value, OutputCollector output, Reporter reporter)
           
 

Uses of Writable in org.apache.hadoop.dfs
 

Classes in org.apache.hadoop.dfs that implement Writable
 class DatanodeDescriptor
          DatanodeDescriptor tracks stats on a given DataNode, such as available storage capacity, last update time, etc., and maintains a set of blocks stored on the datanode.
 class DatanodeID
          DatanodeID is composed of the data node name (hostname:portNumber) and the data storage ID, which it currently represents.
 class DatanodeInfo
          DatanodeInfo represents the status of a DataNode.
 class LocatedBlocks
          Collection of blocks with their locations and the file length.
 class UpgradeStatusReport
          Base upgrade upgradeStatus class.
 

Uses of Writable in org.apache.hadoop.examples
 

Methods in org.apache.hadoop.examples with parameters of type Writable
 void PiEstimator.PiMapper.map(LongWritable key, Writable val, OutputCollector<LongWritable,LongWritable> out, Reporter reporter)
          Map method.
 

Method parameters in org.apache.hadoop.examples with type arguments of type Writable
 void PiEstimator.PiReducer.reduce(LongWritable key, Iterator<LongWritable> values, OutputCollector<WritableComparable,Writable> output, Reporter reporter)
          Reduce method.
 

Uses of Writable in org.apache.hadoop.fs
 

Classes in org.apache.hadoop.fs that implement Writable
 class FileStatus
          Interface that represents the client side information for a file.
 

Uses of Writable in org.apache.hadoop.hbase
 

Classes in org.apache.hadoop.hbase that implement Writable
 class BloomFilterDescriptor
          Supplied as a parameter to HColumnDescriptor to specify what kind of bloom filter to use for a column, and its configuration parameters.
 class HColumnDescriptor
          An HColumnDescriptor contains information about a column family such as the number of versions, compression settings, etc.
 class HLogEdit
          A log value.
 class HLogKey
          A Key for an entry in the change log.
 class HMsg
          HMsg is for communicating instructions between the HMaster and the HRegionServers.
 class HRegionInfo
          HRegion information.
 class HServerAddress
          HServerAddress is a "label" for a HBase server that combines the host name and port number.
 class HServerInfo
          HServerInfo contains metainfo about an HRegionServer, Currently it only contains the server start code.
 class HServerLoad
          This class encapsulates metrics for determining the load on a HRegionServer
 class HStoreFile
          A HStore data file.
 class HStoreKey
          A Key for a stored row
 class HTableDescriptor
          HTableDescriptor contains the name of an HTable, and its column families.
 

Uses of Writable in org.apache.hadoop.hbase.filter
 

Subinterfaces of Writable in org.apache.hadoop.hbase.filter
 interface RowFilterInterface
          Interface used for row-level filters applied to HRegion.HScanner scan results during calls to next().
 

Classes in org.apache.hadoop.hbase.filter that implement Writable
 class PageRowFilter
          Implementation of RowFilterInterface that limits results to a specific page size.
 class RegExpRowFilter
          Implementation of RowFilterInterface that can filter by rowkey regular expression and/or individual column values (equals comparison only).
 class RowFilterSet
          Implementation of RowFilterInterface that represents a set of RowFilters which will be evaluated with a specified boolean operator MUST_PASS_ALL (!AND) or MUST_PASS_ONE (!OR).
 class StopRowFilter
          Implementation of RowFilterInterface that filters out rows greater than or equal to a specified rowKey.
 class WhileMatchRowFilter
          WhileMatchRowFilter is a wrapper filter that filters everything after the first filtered row.
 

Uses of Writable in org.apache.hadoop.hbase.io
 

Classes in org.apache.hadoop.hbase.io that implement Writable
 class BatchOperation
          Batch update operations such as put, delete, and deleteAll.
 class BatchUpdate
          A Writable object that contains a series of BatchOperations There is one BatchUpdate object per server, so a series of batch operations can result in multiple BatchUpdate objects if the batch contains rows that are served by multiple region servers.
 class ImmutableBytesWritable
          A byte sequence that is usable as a key or value.
 

Uses of Writable in org.apache.hadoop.hbase.mapred
 

Classes in org.apache.hadoop.hbase.mapred that implement Writable
 class TableSplit
          A table split corresponds to a key range [low, high)
 

Methods in org.apache.hadoop.hbase.mapred with parameters of type Writable
 void TableMap.map(WritableComparable key, Writable value, OutputCollector output, Reporter reporter)
          Input:
 

Uses of Writable in org.apache.hadoop.hbase.util
 

Methods in org.apache.hadoop.hbase.util that return Writable
static Writable Writables.copyWritable(Writable src, Writable tgt)
          Copy one Writable to another.
static Writable Writables.getWritable(byte[] bytes, Writable w)
          Set bytes into the passed Writable by calling its readFields(java.io.DataInput).
 

Methods in org.apache.hadoop.hbase.util with parameters of type Writable
static Writable Writables.copyWritable(Writable src, Writable tgt)
          Copy one Writable to another.
static byte[] Writables.getBytes(Writable w)
           
static Writable Writables.getWritable(byte[] bytes, Writable w)
          Set bytes into the passed Writable by calling its readFields(java.io.DataInput).
 

Uses of Writable in org.apache.hadoop.io
 

Subinterfaces of Writable in org.apache.hadoop.io
 interface WritableComparable
          A Writable which is also Comparable.
 

Classes in org.apache.hadoop.io that implement Writable
 class AbstractMapWritable
          Abstract base class for MapWritable and SortedMapWritable Unlike org.apache.nutch.crawl.MapWritable, this class allows creation of MapWritable<Writable, MapWritable> so the CLASS_TO_ID and ID_TO_CLASS maps travel with the class instead of being static.
 class ArrayWritable
          A Writable for arrays containing instances of a class.
 class BooleanWritable
          A WritableComparable for booleans.
 class BytesWritable
          A byte sequence that is usable as a key or value.
 class CompressedWritable
          A base-class for Writables which store themselves compressed and lazily inflate on field access.
 class FloatWritable
          A WritableComparable for floats.
 class GenericWritable
          A wrapper for Writable instances.
 class IntWritable
          A WritableComparable for ints.
 class LongWritable
          A WritableComparable for longs.
 class MapWritable
          A Writable Map.
 class MD5Hash
          A Writable for MD5 hash values.
 class NullWritable
          Singleton Writable with no data.
 class ObjectWritable
          A polymorphic Writable that writes an instance with it's class name.
static class SequenceFile.Metadata
          The class encapsulating with the metadata of a file.
 class SortedMapWritable
          A Writable SortedMap.
 class Text
          This class stores text using standard UTF8 encoding.
 class TwoDArrayWritable
          A Writable for 2D arrays containing a matrix of instances of a class.
 class UTF8
          Deprecated. replaced by Text
 class VersionedWritable
          A base class for Writables that provides version checking.
 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 Writable
static Writable WritableUtils.clone(Writable orig, JobConf conf)
          Make a copy of a writable object using serialization to a buffer.
 Writable[][] TwoDArrayWritable.get()
           
 Writable GenericWritable.get()
          Return the wrapped instance.
 Writable[] ArrayWritable.get()
           
 Writable ArrayFile.Reader.get(long n, Writable value)
          Return the nth value in the file.
 Writable SortedMapWritable.get(Object key)
          
 Writable MapWritable.get(Object key)
          
 Writable MapFile.Reader.get(WritableComparable key, Writable val)
          Return the value for the named key, or null if none exists.
 Writable WritableFactory.newInstance()
          Return a new instance.
static Writable WritableFactories.newInstance(Class c)
          Create a new instance of a class with a defined factory.
static Writable WritableFactories.newInstance(Class c, Configuration conf)
          Create a new instance of a class with a defined factory.
 Writable ArrayFile.Reader.next(Writable value)
          Read and return the next value in the file.
 Writable SortedMapWritable.put(WritableComparable key, Writable value)
          
 Writable MapWritable.put(Writable key, Writable value)
          
 Writable SortedMapWritable.remove(Object key)
          
 Writable MapWritable.remove(Object key)
          
 

Methods in org.apache.hadoop.io that return types with arguments of type Writable
 Set<Map.Entry<WritableComparable,Writable>> SortedMapWritable.entrySet()
          
 Set<Map.Entry<Writable,Writable>> MapWritable.entrySet()
          
 Set<Map.Entry<Writable,Writable>> MapWritable.entrySet()
          
 SortedMap<WritableComparable,Writable> SortedMapWritable.headMap(WritableComparable toKey)
          
 Set<Writable> MapWritable.keySet()
          
 SortedMap<WritableComparable,Writable> SortedMapWritable.subMap(WritableComparable fromKey, WritableComparable toKey)
          
 SortedMap<WritableComparable,Writable> SortedMapWritable.tailMap(WritableComparable fromKey)
          
 Collection<Writable> SortedMapWritable.values()
          
 Collection<Writable> MapWritable.values()
          
 

Methods in org.apache.hadoop.io with parameters of type Writable
 void ArrayFile.Writer.append(Writable value)
          Append a value to the file.
 void MapFile.Writer.append(WritableComparable key, Writable val)
          Append a key/value pair to the map.
 void SequenceFile.Writer.append(Writable key, Writable val)
          Append a key/value pair.
static Writable WritableUtils.clone(Writable orig, JobConf conf)
          Make a copy of a writable object using serialization to a buffer.
protected  void AbstractMapWritable.copy(Writable other)
          Used by child copy constructors.
 Writable ArrayFile.Reader.get(long n, Writable value)
          Return the nth value in the file.
 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.
 void SequenceFile.Reader.getCurrentValue(Writable val)
          Get the 'value' corresponding to the last read 'key'.
 Writable ArrayFile.Reader.next(Writable value)
          Read and return the next value in the file.
 boolean SequenceFile.Reader.next(Writable key)
          Read the next key in the file into key, skipping its value.
 boolean MapFile.Reader.next(WritableComparable key, Writable val)
          Read the next key/value pair in the map into key and val.
 boolean SequenceFile.Reader.next(Writable key, Writable val)
          Read the next key/value pair in the file into key and val.
 Writable SortedMapWritable.put(WritableComparable key, Writable value)
          
 Writable MapWritable.put(Writable key, Writable value)
          
 void GenericWritable.set(Writable obj)
          Set the instance that is wrapped.
 void ArrayWritable.set(Writable[] values)
           
 void TwoDArrayWritable.set(Writable[][] values)
           
 

Method parameters in org.apache.hadoop.io with type arguments of type Writable
 void MapWritable.putAll(Map<? extends Writable,? extends Writable> t)
          
 void MapWritable.putAll(Map<? extends Writable,? extends Writable> t)
          
 void SortedMapWritable.putAll(Map<? extends WritableComparable,? extends Writable> t)
          
 

Constructors in org.apache.hadoop.io with parameters of type Writable
ArrayWritable(Class valueClass, Writable[] values)
           
TwoDArrayWritable(Class valueClass, Writable[][] values)
           
 

Uses of Writable in org.apache.hadoop.ipc
 

Methods in org.apache.hadoop.ipc that return Writable
 Writable RPC.Server.call(Writable param)
           
abstract  Writable Server.call(Writable param)
          Called for each call.
 Writable[] Client.call(Writable[] params, InetSocketAddress[] addresses)
          Makes a set of calls in parallel.
 Writable Client.call(Writable param, InetSocketAddress address)
          Make a call, passing param, to the IPC server running at address, returning the value.
 

Methods in org.apache.hadoop.ipc with parameters of type Writable
 Writable RPC.Server.call(Writable param)
           
abstract  Writable Server.call(Writable param)
          Called for each call.
 Writable[] Client.call(Writable[] params, InetSocketAddress[] addresses)
          Makes a set of calls in parallel.
 Writable Client.call(Writable param, InetSocketAddress address)
          Make a call, passing param, to the IPC server running at address, returning the value.
 

Uses of Writable in org.apache.hadoop.mapred
 

Classes in org.apache.hadoop.mapred with type parameters of type Writable
 class FileInputFormat<K extends WritableComparable,V extends Writable>
          A base class for file-based InputFormat.
 interface InputFormat<K extends WritableComparable,V extends Writable>
          InputFormat describes the input-specification for a Map-Reduce job.
 interface Mapper<K1 extends WritableComparable,V1 extends Writable,K2 extends WritableComparable,V2 extends Writable>
          Maps input key/value pairs to a set of intermediate key/value pairs.
 interface Mapper<K1 extends WritableComparable,V1 extends Writable,K2 extends WritableComparable,V2 extends Writable>
          Maps input key/value pairs to a set of intermediate key/value pairs.
 interface MapRunnable<K1 extends WritableComparable,V1 extends Writable,K2 extends WritableComparable,V2 extends Writable>
          Expert: Generic interface for Mappers.
 interface MapRunnable<K1 extends WritableComparable,V1 extends Writable,K2 extends WritableComparable,V2 extends Writable>
          Expert: Generic interface for Mappers.
 class MapRunner<K1 extends WritableComparable,V1 extends Writable,K2 extends WritableComparable,V2 extends Writable>
          Default MapRunnable implementation.
 class MapRunner<K1 extends WritableComparable,V1 extends Writable,K2 extends WritableComparable,V2 extends Writable>
          Default MapRunnable implementation.
 class MultiFileInputFormat<K extends WritableComparable,V extends Writable>
          An abstract InputFormat that returns MultiFileSplit's in MultiFileInputFormat.getSplits(JobConf, int) method.
 interface OutputCollector<K extends WritableComparable,V extends Writable>
          Collects the <key, value> pairs output by Mappers and Reducers.
 interface OutputFormat<K extends WritableComparable,V extends Writable>
          OutputFormat describes the output-specification for a Map-Reduce job.
 class OutputFormatBase<K extends WritableComparable,V extends Writable>
          A base class for OutputFormat.
 interface Partitioner<K2 extends WritableComparable,V2 extends Writable>
          Partitions the key space.
 interface RecordReader<K extends WritableComparable,V extends Writable>
          RecordReader reads <key, value> pairs from an InputSplit.
 interface RecordWriter<K extends WritableComparable,V extends Writable>
          RecordWriter writes the output <key, value> pairs to an output file.
 interface Reducer<K2 extends WritableComparable,V2 extends Writable,K3 extends WritableComparable,V3 extends Writable>
          Reduces a set of intermediate values which share a key to a smaller set of values.
 interface Reducer<K2 extends WritableComparable,V2 extends Writable,K3 extends WritableComparable,V3 extends Writable>
          Reduces a set of intermediate values which share a key to a smaller set of values.
 class SequenceFileInputFilter<K extends WritableComparable,V extends Writable>
          A class that allows a map/red job to work on a sample of sequence files.
 class SequenceFileInputFormat<K extends WritableComparable,V extends Writable>
          An InputFormat for SequenceFiles.
 class SequenceFileRecordReader<K extends WritableComparable,V extends Writable>
          An RecordReader for SequenceFiles.
 class TextOutputFormat<K extends WritableComparable,V extends Writable>
          An OutputFormat that writes plain text files.
protected static class TextOutputFormat.LineRecordWriter<K extends WritableComparable,V extends Writable>
           
 

Subinterfaces of Writable in org.apache.hadoop.mapred
 interface InputSplit
          InputSplit represents the data to be processed by an individual Mapper.
 

Classes in org.apache.hadoop.mapred that implement Writable
 class ClusterStatus
          Status information on the current state of the Map-Reduce cluster.
 class Counters
          A set of named counters.
 class FileSplit
          A section of an input file.
 class JobProfile
          A JobProfile is a MapReduce primitive.
 class JobStatus
          Describes the current status of a job.
 class MapTaskStatus
           
 class MultiFileSplit
          A sub-collection of input files.
 class ReduceTaskStatus
           
 class TaskCompletionEvent
          This is used to track task completion events on job tracker.
 class TaskReport
          A report on the state of a task.
 

Methods in org.apache.hadoop.mapred with type parameters of type Writable
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 Writable
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 Writable
 Class<? extends Writable> JobConf.getMapOutputValueClass()
          Get the value class for the map output data.
 Class<? extends Writable> JobConf.getOutputValueClass()
          Get the value class for job outputs.
 

Methods in org.apache.hadoop.mapred with parameters of type Writable
 boolean SequenceFileInputFilter.Filter.accept(Writable key)
          filter function Decide if a record should be filtered or not
 boolean SequenceFileInputFilter.RegexFilter.accept(Writable key)
          Filtering method If key matches the regex, return true; otherwise return false
 boolean SequenceFileInputFilter.PercentFilter.accept(Writable key)
          Filtering method If record# % frequency==0, return true; otherwise return false
 boolean SequenceFileInputFilter.MD5Filter.accept(Writable key)
          Filtering method If MD5(key) % frequency==0, return true; otherwise return false
 

Method parameters in org.apache.hadoop.mapred with type arguments of type Writable
 void JobConf.setMapOutputValueClass(Class<? extends Writable> theClass)
          Set the value class for the map output data.
 void JobConf.setOutputValueClass(Class<? extends Writable> theClass)
          Set the value class for job outputs.
 

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

Classes in org.apache.hadoop.mapred.lib with type parameters of type Writable
 class FieldSelectionMapReduce<K extends WritableComparable,V extends Writable>
          This class implements a mapper/reducer class that can be used to perform field selections in a manner similar to unix cut.
 class HashPartitioner<K2 extends WritableComparable,V2 extends Writable>
          Partition keys by their Object.hashCode().
 class IdentityMapper<K extends WritableComparable,V extends Writable>
          Implements the identity function, mapping inputs directly to outputs.
 class IdentityReducer<K extends WritableComparable,V extends Writable>
          Performs no reduction, writing all input values directly to the output.
 class KeyFieldBasedPartitioner<K2 extends WritableComparable,V2 extends Writable>
           
 class MultithreadedMapRunner<K1 extends WritableComparable,V1 extends Writable,K2 extends WritableComparable,V2 extends Writable>
          Multithreaded implementation for @link org.apache.hadoop.mapred.MapRunnable.
 class MultithreadedMapRunner<K1 extends WritableComparable,V1 extends Writable,K2 extends WritableComparable,V2 extends Writable>
          Multithreaded implementation for @link org.apache.hadoop.mapred.MapRunnable.
 class NullOutputFormat<K extends WritableComparable,V extends Writable>
          Consume all outputs and put them in /dev/null.
 

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

Classes in org.apache.hadoop.mapred.lib.aggregate with type parameters of type Writable
 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 Writable in org.apache.hadoop.record
 

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

Uses of Writable in org.apache.hadoop.streaming
 

Methods in org.apache.hadoop.streaming with parameters of type Writable
 void PipeMapper.map(WritableComparable key, Writable value, OutputCollector output, Reporter reporter)
           
 

Uses of Writable in org.onelab.filter
 

Classes in org.onelab.filter that implement Writable
 class BloomFilter
          Implements a Bloom filter, as defined by Bloom in 1970.
 class CountingBloomFilter
          Implements a counting Bloom filter, as defined by Fan et al.
 class DynamicBloomFilter
          Implements a dynamic Bloom filter, as defined in the INFOCOM 2006 paper.
 class Filter
          Defines the general behavior of a filter.
 class Key
          The general behavior of a key that must be stored in a filter.
 class RetouchedBloomFilter
          Implements a retouched Bloom filter, as defined in the CoNEXT 2006 paper.
 



Copyright © 2006 The Apache Software Foundation