public SequenceFileRecordReader(Configuration conf,
    FileSplit split) throws IOException 
{
      
    Path path = split.getPath();
    FileSystem fs = path.getFileSystem(conf);
    this.in = new SequenceFile.Reader(fs, path, conf);
    this.end = split.getStart() + split.getLength();
    this.conf = conf;
    if (split.getStart()  > in.getPosition())
      in.sync(split.getStart());                  // sync to start
    this.start = in.getPosition();
    more = start <  end;
}

 public synchronized  void close() throws IOException 
{
 in.close();
}

 public WritableComparable createKey() 
{
    return (WritableComparable) ReflectionUtils.newInstance(getKeyClass(), 
                                                            conf);
}

 public Writable createValue() 
{
    return (Writable) ReflectionUtils.newInstance(getValueClass(), conf);
}

 protected synchronized  void getCurrentValue(Writable value) throws IOException 
{
    in.getCurrentValue(value);
}

 public Class getKeyClass() 
{
 return in.getKeyClass();
}

The class of key that must be passed to #next(Writable,Writable) ..

 public synchronized long getPos() throws IOException 
{
    return in.getPosition();
}

 public float getProgress() throws IOException 
{
    if (end == start) {
      return 0.0f;
    } else {
      return Math.min(1.0f, (in.getPosition() - start) / (float)(end - start));
    }
}

Return the progress within the input split

 public Class getValueClass() 
{
 return in.getValueClass();
}

The class of value that must be passed to #next(Writable,Writable) ..

 protected synchronized boolean next(Writable key) throws IOException 
{
    if (!more) return false;
    long pos = in.getPosition();
    boolean eof = in.next(key);
    if (pos  >= end && in.syncSeen()) {
      more = false;
    } else {
      more = eof;
    }
    return more;
}

 public synchronized boolean next(Writable key,
    Writable value) throws IOException 
{
    if (!more) return false;
    long pos = in.getPosition();
    boolean eof = in.next(key, value);
    if (pos  >= end && in.syncSeen()) {
      more = false;
    } else {
      more = eof;
    }
    return more;
}

 protected synchronized  void seek(long pos) throws IOException 
{
    in.seek(pos);
}