SYMBOL INDEX (1874 symbols across 206 files)

FILE: .travis/check_script_template.py
  function main (line 21) | def main(argv):

FILE: dev_tools/docker/clusters/apache_2.6.0/images/base/scripts/generate_conf_files.py
  function add_property (line 6) | def add_property(conf, name, value):
  function write_xml (line 12) | def write_xml(root, fname):
  function generate_xml_conf_file (line 20) | def generate_xml_conf_file(fname, props):
  function generate_core_site (line 27) | def generate_core_site(fname):
  function generate_hdfs_site (line 35) | def generate_hdfs_site(fname):
  function generate_yarn_site (line 46) | def generate_yarn_site(fname):
  function generate_mapred_site (line 68) | def generate_mapred_site(fname):
  function generate_capacity_scheduler (line 86) | def generate_capacity_scheduler(fname):
  function main (line 100) | def main(argv):

FILE: dev_tools/docker/clusters/apache_2.6.0/images/bootstrap/scripts/bootstrap.py
  function etc_updated (line 15) | def etc_updated():
  function boot_node (line 25) | def boot_node(kz, nodename):
  function main (line 34) | def main():

FILE: dev_tools/docker/scripts/share_etc_hosts.py
  class App (line 15) | class App(object):
    method __init__ (line 16) | def __init__(self, compose_group_name):
    method _get_containers (line 20) | def _get_containers(self, compose_group_name):
    method _get_hosts (line 26) | def _get_hosts(self):
    method share_etc_hosts (line 34) | def share_etc_hosts(self):
  function docker_client (line 44) | def docker_client():
  function main (line 78) | def main(argv):

FILE: examples/avro/py/avro_base.py
  class ColorPickBase (line 29) | class ColorPickBase(api.Mapper):
    method get_user (line 32) | def get_user(self, ctx):
    method map (line 40) | def map(self, ctx):
  class AvroKeyColorPick (line 47) | class AvroKeyColorPick(ColorPickBase):
    method get_user (line 49) | def get_user(self, ctx):
  class AvroValueColorPick (line 53) | class AvroValueColorPick(ColorPickBase):
    method get_user (line 55) | def get_user(self, ctx):
  class AvroKeyValueColorPick (line 59) | class AvroKeyValueColorPick(ColorPickBase):
    method get_user (line 61) | def get_user(self, ctx):
    method map (line 64) | def map(self, ctx):
  class ColorCountBase (line 69) | class ColorCountBase(api.Reducer):
    method reduce (line 71) | def reduce(self, ctx):
    method emit (line 76) | def emit(self, s, ctx):
  class NoAvroColorCount (line 83) | class NoAvroColorCount(ColorCountBase):
    method emit (line 85) | def emit(self, s, ctx):
  class AvroKeyColorCount (line 89) | class AvroKeyColorCount(ColorCountBase):
    method emit (line 91) | def emit(self, s, ctx):
  class AvroValueColorCount (line 95) | class AvroValueColorCount(ColorCountBase):
    method emit (line 97) | def emit(self, s, ctx):
  class AvroKeyValueColorCount (line 101) | class AvroKeyValueColorCount(ColorCountBase):
    method emit (line 103) | def emit(self, s, ctx):
  function run_task (line 108) | def run_task(mapper_class, reducer_class=NoAvroColorCount):

FILE: examples/avro/py/avro_container_dump_results.py
  function main (line 25) | def main(fn, out_fn, avro_mode=''):

FILE: examples/avro/py/avro_key_in.py
  function __main__ (line 24) | def __main__():

FILE: examples/avro/py/avro_key_in_out.py
  function __main__ (line 24) | def __main__():

FILE: examples/avro/py/avro_key_value_in.py
  function __main__ (line 24) | def __main__():

FILE: examples/avro/py/avro_key_value_in_out.py
  function __main__ (line 24) | def __main__():

FILE: examples/avro/py/avro_parquet_dump_results.py
  class Mapper (line 25) | class Mapper(api.Mapper):
    method map (line 27) | def map(self, ctx):
  function __main__ (line 32) | def __main__():

FILE: examples/avro/py/avro_pyrw.py
  class UserReader (line 32) | class UserReader(AvroReader):
  class ColorWriter (line 36) | class ColorWriter(AvroWriter):
    method emit (line 40) | def emit(self, key, value):
  class ColorPick (line 44) | class ColorPick(api.Mapper):
    method map (line 46) | def map(self, ctx):
  class ColorCount (line 53) | class ColorCount(api.Reducer):
    method reduce (line 55) | def reduce(self, ctx):

FILE: examples/avro/py/avro_value_in.py
  function __main__ (line 24) | def __main__():

FILE: examples/avro/py/avro_value_in_out.py
  function __main__ (line 24) | def __main__():

FILE: examples/avro/py/check_cc.py
  function iter_fnames (line 29) | def iter_fnames(path):
  function main (line 40) | def main(in_, out_):

FILE: examples/avro/py/check_results.py
  function iter_lines (line 27) | def iter_lines(path):
  function main (line 39) | def main(exp, res):

FILE: examples/avro/py/color_count.py
  class Mapper (line 28) | class Mapper(api.Mapper):
    method map (line 30) | def map(self, ctx):
  class Reducer (line 37) | class Reducer(api.Reducer):
    method reduce (line 39) | def reduce(self, ctx):
  function __main__ (line 44) | def __main__():

FILE: examples/avro/py/create_input.py
  function create_input (line 27) | def create_input(n, stream):
  function main (line 36) | def main(n, filename):

FILE: examples/avro/py/gen_data.py
  class Mapper (line 27) | class Mapper(api.Mapper):
    method map (line 29) | def map(self, ctx):
  function __main__ (line 35) | def __main__():

FILE: examples/avro/py/generate_avro_users.py
  function main (line 37) | def main(argv):

FILE: examples/avro/py/kmer_count.py
  function window (line 28) | def window(s, width):
  class Mapper (line 33) | class Mapper(api.Mapper):
    method map (line 35) | def map(self, ctx):
  class Reducer (line 41) | class Reducer(api.Reducer):
    method reduce (line 43) | def reduce(self, ctx):
  function __main__ (line 47) | def __main__():

FILE: examples/avro/py/show_kmer_count.py
  function main (line 26) | def main(argv):

FILE: examples/avro/py/write_avro.py
  function main (line 30) | def main(schema_fn, csv_fn, avro_fn):

FILE: examples/avro/src/main/java/it/crs4/pydoop/WriteKV.java
  class WriteKV (line 41) | class WriteKV {
    method buildUser (line 45) | private static GenericRecord buildUser(
    method buildPet (line 54) | private static GenericRecord buildPet(
    method createFile (line 62) | private static <T> File createFile(File file, Schema schema, T... reco...
    method createInputFile (line 74) | private static File createInputFile(
    method main (line 106) | public static void main(String[] args) throws Exception {

FILE: examples/avro/src/main/java/it/crs4/pydoop/WriteParquet.java
  class WriteParquet (line 53) | public class WriteParquet extends Configured implements Tool {
    method getSchema (line 60) | private static Schema getSchema(Configuration conf)
    class WriteUserMap (line 70) | public static class WriteUserMap
      method setup (line 75) | @Override
      method map (line 81) | @Override
    method run (line 94) | public int run(String[] args) throws Exception {
    method main (line 129) | public static void main(String[] args) throws Exception {

FILE: examples/c++/HadoopPipes.cc
  type HadoopPipes (line 48) | namespace HadoopPipes {
    class JobConfImpl (line 50) | class JobConfImpl: public JobConf {
      method set (line 54) | void set(const string& key, const string& value) {
      method hasKey (line 58) | virtual bool hasKey(const string& key) const {
      method string (line 62) | virtual const string& get(const string& key) const {
      method getInt (line 70) | virtual int getInt(const string& key) const {
      method getFloat (line 75) | virtual float getFloat(const string& key) const {
      method getBoolean (line 80) | virtual bool getBoolean(const string&key) const {
    class DownwardProtocol (line 86) | class DownwardProtocol {
    class UpwardProtocol (line 101) | class UpwardProtocol {
    class Protocol (line 116) | class Protocol {
    class TextUpwardProtocol (line 123) | class TextUpwardProtocol: public UpwardProtocol {
      method writeBuffer (line 129) | void writeBuffer(const string& buffer) {
      method TextUpwardProtocol (line 134) | TextUpwardProtocol(FILE* _stream): stream(_stream) {}
      method output (line 136) | virtual void output(const string& key, const string& value) {
      method partitionedOutput (line 144) | virtual void partitionedOutput(int reduce, const string& key,
      method status (line 154) | virtual void status(const string& message) {
      method progress (line 159) | virtual void progress(float progress) {
      method registerCounter (line 164) | virtual void registerCounter(int id, const string& group,
      method incrementCounter (line 171) | virtual void incrementCounter(const TaskContext::Counter* counter,
      method done (line 177) | virtual void done() {
    class TextProtocol (line 182) | class TextProtocol: public Protocol {
      method readUpto (line 190) | int readUpto(string& buffer, const char* limit) {
      method TextProtocol (line 205) | TextProtocol(FILE* down, DownwardProtocol* _handler, FILE* up) {
      method UpwardProtocol (line 211) | UpwardProtocol* getUplink() {
      method nextEvent (line 215) | virtual void nextEvent() {
    type MESSAGE_TYPE (line 297) | enum MESSAGE_TYPE {START_MESSAGE, SET_JOB_CONF, SET_INPUT_TYPES, RUN_MAP,
    class BinaryUpwardProtocol (line 303) | class BinaryUpwardProtocol: public UpwardProtocol {
      method BinaryUpwardProtocol (line 307) | BinaryUpwardProtocol(FILE* _stream) {
      method authenticate (line 312) | virtual void authenticate(const string &responseDigest) {
      method output (line 318) | virtual void output(const string& key, const string& value) {
      method partitionedOutput (line 324) | virtual void partitionedOutput(int reduce, const string& key,
      method status (line 332) | virtual void status(const string& message) {
      method progress (line 337) | virtual void progress(float progress) {
      method done (line 343) | virtual void done() {
      method registerCounter (line 347) | virtual void registerCounter(int id, const string& group,
      method incrementCounter (line 355) | virtual void incrementCounter(const TaskContext::Counter* counter,
    class BinaryProtocol (line 367) | class BinaryProtocol: public Protocol {
      method getPassword (line 376) | void getPassword(string &password) {
      method verifyDigestAndRespond (line 396) | void verifyDigestAndRespond(string& digest, string& challenge) {
      method verifyDigest (line 413) | bool verifyDigest(string &password, string& digest, string& challeng...
      method string (line 422) | string createDigest(string &password, string& msg) {
      method BinaryProtocol (line 462) | BinaryProtocol(FILE* down, DownwardProtocol* _handler, FILE* up) {
      method UpwardProtocol (line 471) | UpwardProtocol* getUplink() {
      method nextEvent (line 475) | virtual void nextEvent() {
    class CombineContext (line 575) | class CombineContext: public ReduceContext {
      method CombineContext (line 589) | CombineContext(ReduceContext* _baseContext,
      method JobConf (line 604) | virtual const JobConf* getJobConf() {
      method emit (line 616) | virtual void emit(const std::string& key, const std::string& value) {
      method progress (line 625) | virtual void progress() {
      method setStatus (line 629) | virtual void setStatus(const std::string& status) {
      method nextKey (line 633) | bool nextKey() {
      method nextValue (line 648) | virtual bool nextValue() {
      method Counter (line 657) | virtual Counter* getCounter(const std::string& group,
      method incrementCounter (line 662) | virtual void incrementCounter(const Counter* counter, uint64_t amoun...
    class CombineRunner (line 671) | class CombineRunner: public RecordWriter {
      method CombineRunner (line 682) | CombineRunner(int64_t _spillSize, ReduceContext* _baseContext,
      method emit (line 694) | virtual void emit(const std::string& key,
      method close (line 703) | virtual void close() {
      method spillAll (line 708) | void spillAll() {
    class TaskContextImpl (line 719) | class TaskContextImpl: public MapContext, public ReduceContext,
      method TaskContextImpl (line 751) | TaskContextImpl(const Factory& _factory) {
      method setProtocol (line 774) | void setProtocol(Protocol* _protocol, UpwardProtocol* _uplink) {
      method start (line 780) | virtual void start(int protocol) {
      method setJobConf (line 787) | virtual void setJobConf(vector<string> values) {
      method setInputTypes (line 797) | virtual void setInputTypes(string keyType, string valueType) {
      method runMap (line 802) | virtual void runMap(string _inputSplit, int _numReduces, bool pipedI...
      method mapItem (line 828) | virtual void mapItem(const string& _key, const string& _value) {
      method runReduce (line 834) | virtual void runReduce(int reduce, bool pipedOutput) {
      method reduceKey (line 843) | virtual void reduceKey(const string& _key) {
      method reduceValue (line 848) | virtual void reduceValue(const string& _value) {
      method isDone (line 853) | virtual bool isDone() {
      method close (line 860) | virtual void close() {
      method abort (line 866) | virtual void abort() {
      method waitForTask (line 870) | void waitForTask() {
      method nextKey (line 876) | bool nextKey() {
      method nextValue (line 906) | virtual bool nextValue() {
      method JobConf (line 919) | virtual JobConf* getJobConf() {
      method string (line 927) | virtual const string& getInputKey() {
      method string (line 936) | virtual const string& getInputValue() {
      method progress (line 944) | virtual void progress() {
      method setStatus (line 961) | virtual void setStatus(const string& status) {
      method string (line 970) | virtual const string& getInputKeyClass() {
      method string (line 977) | virtual const string& getInputValueClass() {
      method emit (line 988) | virtual void emit(const string& key, const string& value) {
      method Counter (line 1003) | virtual Counter* getCounter(const std::string& group,
      method incrementCounter (line 1014) | virtual void incrementCounter(const Counter* counter, uint64_t amoun...
      method closeAll (line 1018) | void closeAll() {
    function runTask (line 1104) | bool runTask(const Factory& factory) {

FILE: examples/c++/SerialUtils.cc
  type HadoopUtils (line 29) | namespace HadoopUtils {
    function serializeInt (line 178) | void serializeInt(int32_t t, OutStream& stream) {
    function serializeLong (line 182) | void serializeLong(int64_t t, OutStream& stream)
    function deserializeInt (line 213) | int32_t deserializeInt(InStream& stream) {
    function deserializeLong (line 217) | int64_t deserializeLong(InStream& stream)
    function serializeFloat (line 246) | void serializeFloat(float t, OutStream& stream)
    function deserializeFloat (line 255) | float deserializeFloat(InStream& stream)
    function deserializeFloat (line 262) | void deserializeFloat(float& t, InStream& stream)
    function serializeString (line 271) | void serializeString(const std::string& t, OutStream& stream)
    function deserializeString (line 279) | void deserializeString(std::string& t, InStream& stream)

FILE: examples/c++/StringUtils.cc
  type HadoopUtils (line 32) | namespace HadoopUtils {
    function string (line 34) | string toString(int32_t x) {
    function toInt (line 40) | int toInt(const string& val) {
    function toFloat (line 49) | float toFloat(const string& val) {
    function toBool (line 58) | bool toBool(const string& val) {
    function getCurrentMillis (line 72) | uint64_t getCurrentMillis() {
    function splitString (line 80) | vector<string> splitString(const std::string& str,
    function string (line 97) | string quoteString(const string& str,
    function string (line 129) | string unquoteString(const string& str) {

FILE: examples/c++/include/hadoop/Pipes.hh
  class ReduceContext (line 141) | class ReduceContext: public TaskContext {
  class Closable (line 149) | class Closable {
    method close (line 151) | virtual void close() {}
  class Mapper (line 158) | class Mapper: public Closable {
  class Reducer (line 166) | class Reducer: public Closable {
  class Partitioner (line 174) | class Partitioner {
  class RecordReader (line 184) | class RecordReader: public Closable {
  class RecordWriter (line 198) | class RecordWriter: public Closable {
  class Factory (line 207) | class Factory {
    method Reducer (line 216) | virtual Reducer* createCombiner(MapContext& context) const {
    method Partitioner (line 225) | virtual Partitioner* createPartitioner(MapContext& context) const {
    method RecordReader (line 234) | virtual RecordReader* createRecordReader(MapContext& context) const {
    method RecordWriter (line 243) | virtual RecordWriter* createRecordWriter(ReduceContext& context) const {

FILE: examples/c++/include/hadoop/SerialUtils.hh
  type HadoopUtils (line 24) | namespace HadoopUtils {
    class Error (line 29) | class Error {
    class InStream (line 68) | class InStream {
    class OutStream (line 83) | class OutStream {
    class FileInStream (line 102) | class FileInStream : public InStream {
    class FileOutStream (line 125) | class FileOutStream: public OutStream {
    class StringInStream (line 151) | class StringInStream: public InStream {

FILE: examples/c++/include/hadoop/StringUtils.hh
  type HadoopUtils (line 25) | namespace HadoopUtils {

FILE: examples/c++/include/hadoop/TemplateFactory.hh
  type HadoopPipes (line 21) | namespace HadoopPipes {
    class TemplateFactory2 (line 24) | class TemplateFactory2: public Factory {
      method Mapper (line 26) | Mapper* createMapper(MapContext& context) const {
      method Reducer (line 29) | Reducer* createReducer(ReduceContext& context) const {
    class TemplateFactory3 (line 35) | class TemplateFactory3: public TemplateFactory2<mapper,reducer> {
      method Partitioner (line 37) | Partitioner* createPartitioner(MapContext& context) const {
    class TemplateFactory3<mapper, reducer, void> (line 43) | class TemplateFactory3<mapper, reducer, void>
    class TemplateFactory4 (line 48) | class TemplateFactory4
      method Reducer (line 51) | Reducer* createCombiner(MapContext& context) const {
    class TemplateFactory4<mapper,reducer,partitioner,void> (line 57) | class TemplateFactory4<mapper,reducer,partitioner,void>
    class TemplateFactory5 (line 63) | class TemplateFactory5
      method RecordReader (line 66) | RecordReader* createRecordReader(MapContext& context) const {
    class TemplateFactory5<mapper,reducer,partitioner,combiner,void> (line 72) | class TemplateFactory5<mapper,reducer,partitioner,combiner,void>
    class TemplateFactory (line 79) | class TemplateFactory
      method RecordWriter (line 82) | RecordWriter* createRecordWriter(ReduceContext& context) const {
    class TemplateFactory<mapper, reducer, partitioner, combiner, recordReader, 
                        void> (line 89) | class TemplateFactory<mapper, reducer, partitioner, combiner, recordRe...

FILE: examples/c++/wordcount.cc
  function deserializeLongWritable (line 31) | int64_t deserializeLongWritable(std::string s) {
  class Mapper (line 43) | class Mapper: public HadoopPipes::Mapper {
    method Mapper (line 46) | Mapper(HadoopPipes::TaskContext &context) { }
    method map (line 48) | void map(HadoopPipes::MapContext &context) {
  class Reducer (line 61) | class Reducer: public HadoopPipes::Reducer {
    method Reducer (line 64) | Reducer(HadoopPipes::TaskContext &context) { }
    method reduce (line 66) | void reduce(HadoopPipes::ReduceContext &context) {
  function main (line 76) | int main(int argc, char *argv[]) {

FILE: examples/hdfs/common.py
  function isdir (line 25) | def isdir(fs, d):

FILE: examples/hdfs/repl_session.py
  function clean (line 46) | def clean():

FILE: examples/hdfs/treegen.py
  function treegen (line 34) | def treegen(fs, root, depth, span):
  function main (line 52) | def main(argv):

FILE: examples/hdfs/treewalk.py
  function usage_by_bs (line 27) | def usage_by_bs(fs, root):

FILE: examples/input_format/check_results.py
  function get_res (line 28) | def get_res(output_dir):
  function check (line 33) | def check(measured_res, expected_res):
  function main (line 41) | def main(argv):

FILE: examples/input_format/it/crs4/pydoop/mapred/TextInputFormat.java
  class TextInputFormat (line 29) | public class TextInputFormat extends FileInputFormat<LongWritable, Text>
    method configure (line 34) | public void configure(JobConf conf) {
    method isSplitable (line 38) | protected boolean isSplitable(FileSystem fs, Path file) {
    method getRecordReader (line 42) | public RecordReader<LongWritable, Text> getRecordReader(

FILE: examples/input_format/it/crs4/pydoop/mapreduce/TextInputFormat.java
  class TextInputFormat (line 33) | public class TextInputFormat extends FileInputFormat<LongWritable, Text> {
    method createRecordReader (line 35) | @Override
    method isSplitable (line 41) | @Override

FILE: examples/pydoop_script/check.py
  function check_base_histogram (line 43) | def check_base_histogram(mr_out_dir):
  function check_caseswitch (line 58) | def check_caseswitch(mr_out_dir, switch="upper"):
  function check_grep (line 67) | def check_grep(mr_out_dir):
  function check_lowercase (line 79) | def check_lowercase(mr_out_dir):
  function check_transpose (line 83) | def check_transpose(mr_out_dir):
  function check_wordcount (line 104) | def check_wordcount(mr_out_dir, stop_words=None):
  function check_wordcount_sw (line 111) | def check_wordcount_sw(mr_out_dir):
  function make_parser (line 120) | def make_parser():
  function main (line 128) | def main(argv):

FILE: examples/pydoop_script/scripts/base_histogram.py
  function mapper (line 27) | def mapper(_, samrecord, writer):
  function reducer (line 34) | def reducer(key, ivalue, writer):

FILE: examples/pydoop_script/scripts/caseswitch.py
  function mapper (line 28) | def mapper(_, record, writer, conf):

FILE: examples/pydoop_script/scripts/grep.py
  function mapper (line 31) | def mapper(_, text, writer, conf):

FILE: examples/pydoop_script/scripts/lowercase.py
  function mapper (line 27) | def mapper(_, record, writer):

FILE: examples/pydoop_script/scripts/transpose.py
  function mapper (line 60) | def mapper(key, value, writer):
  function reducer (line 70) | def reducer(key, ivalue, writer):

FILE: examples/pydoop_script/scripts/wc_combiner.py
  function mapper (line 24) | def mapper(_, text, writer):
  function reducer (line 29) | def reducer(word, icounts, writer):
  function combiner (line 34) | def combiner(word, icounts, writer):

FILE: examples/pydoop_script/scripts/wordcount.py
  function mapper (line 25) | def mapper(_, text, writer):
  function reducer (line 30) | def reducer(word, icounts, writer):

FILE: examples/pydoop_script/scripts/wordcount_sw.py
  function mapper (line 33) | def mapper(_, value, writer):
  function reducer (line 41) | def reducer(word, icounts, writer):

FILE: examples/pydoop_submit/check.py
  function check_wordcount_minimal (line 41) | def check_wordcount_minimal(mr_out_dir):
  function check_nosep (line 51) | def check_nosep(mr_out_dir):
  function check_map_only_python_writer (line 65) | def check_map_only_python_writer(mr_out_dir):

FILE: examples/pydoop_submit/mr/map_only_java_writer.py
  class Mapper (line 27) | class Mapper(api.Mapper):
    method __init__ (line 29) | def __init__(self, context):
    method map (line 32) | def map(self, context):
  function __main__ (line 36) | def __main__():

FILE: examples/pydoop_submit/mr/map_only_python_writer.py
  class Mapper (line 32) | class Mapper(api.Mapper):
    method __init__ (line 34) | def __init__(self, context):
    method map (line 37) | def map(self, context):
  class Writer (line 41) | class Writer(api.RecordWriter):
    method __init__ (line 43) | def __init__(self, context):
    method close (line 53) | def close(self):
    method emit (line 57) | def emit(self, key, value):
  function __main__ (line 61) | def __main__():

FILE: examples/pydoop_submit/mr/nosep.py
  class Mapper (line 25) | class Mapper(api.Mapper):
    method map (line 27) | def map(self, ctx):
  function __main__ (line 32) | def __main__():

FILE: examples/pydoop_submit/mr/wordcount_full.py
  class Mapper (line 34) | class Mapper(api.Mapper):
    method __init__ (line 36) | def __init__(self, context):
    method map (line 41) | def map(self, context):
  class Reducer (line 48) | class Reducer(api.Reducer):
    method __init__ (line 50) | def __init__(self, context):
    method reduce (line 55) | def reduce(self, context):
  class Reader (line 60) | class Reader(api.RecordReader):
    method __init__ (line 65) | def __init__(self, context):
    method close (line 81) | def close(self):
    method next (line 86) | def next(self):
    method get_progress (line 96) | def get_progress(self):
  class Writer (line 100) | class Writer(api.RecordWriter):
    method __init__ (line 102) | def __init__(self, context):
    method close (line 112) | def close(self):
    method emit (line 117) | def emit(self, key, value):
  class Partitioner (line 121) | class Partitioner(api.Partitioner):
    method __init__ (line 123) | def __init__(self, context):
    method partition (line 127) | def partition(self, key, n_reduces):
  function main (line 145) | def main():

FILE: examples/pydoop_submit/mr/wordcount_minimal.py
  class Mapper (line 30) | class Mapper(api.Mapper):
    method map (line 32) | def map(self, context):
  class Reducer (line 37) | class Reducer(api.Reducer):
    method reduce (line 39) | def reduce(self, context):
  function main (line 46) | def main():

FILE: examples/self_contained/check_results.py
  function compute_vc (line 31) | def compute_vc(input_dir):
  function get_res (line 41) | def get_res(output_dir):
  function check (line 45) | def check(measured_res, expected_res):
  function main (line 53) | def main(argv):

FILE: examples/self_contained/vowelcount/lib/__init__.py
  function is_vowel (line 23) | def is_vowel(c):

FILE: examples/self_contained/vowelcount/mr/main.py
  function main (line 24) | def main():

FILE: examples/self_contained/vowelcount/mr/mapper.py
  class Mapper (line 23) | class Mapper(api.Mapper):
    method map (line 25) | def map(self, context):

FILE: examples/self_contained/vowelcount/mr/reducer.py
  class Reducer (line 22) | class Reducer(api.Reducer):
    method reduce (line 24) | def reduce(self, context):

FILE: examples/sequence_file/bin/filter.py
  class FilterMapper (line 31) | class FilterMapper(Mapper):
    method __init__ (line 36) | def __init__(self, context):
    method map (line 41) | def map(self, context):
  function __main__ (line 48) | def __main__():

FILE: examples/sequence_file/bin/wordcount.py
  class WordCountMapper (line 27) | class WordCountMapper(Mapper):
    method map (line 29) | def map(self, context):
  class WordCountReducer (line 34) | class WordCountReducer(Reducer):
    method reduce (line 36) | def reduce(self, context):
  function __main__ (line 41) | def __main__():

FILE: examples/sequence_file/check.py
  function main (line 27) | def main(args):

FILE: int_test/mapred_submitter/check.py
  function get_lines (line 30) | def get_lines(dir_path):
  function check_output (line 41) | def check_output(items, exp_items):
  function check_counters (line 53) | def check_counters(counter, exp_counter):
  function word_count (line 57) | def word_count(lines):
  function check_map_only (line 61) | def check_map_only(in_dir, out_dir):
  function check_map_reduce (line 67) | def check_map_reduce(in_dir, out_dir):
  function check_pstats (line 74) | def check_pstats(pstats_dir):

FILE: int_test/mapred_submitter/genwords.py
  function genfile (line 38) | def genfile(path, size):

FILE: int_test/mapred_submitter/mr/map_only_java_writer.py
  class Mapper (line 25) | class Mapper(api.Mapper):
    method map (line 27) | def map(self, context):
  function __main__ (line 31) | def __main__():

FILE: int_test/mapred_submitter/mr/map_only_python_writer.py
  class Mapper (line 28) | class Mapper(api.Mapper):
    method map (line 30) | def map(self, context):
  class Writer (line 34) | class Writer(api.RecordWriter):
    method __init__ (line 36) | def __init__(self, context):
    method close (line 42) | def close(self):
    method emit (line 45) | def emit(self, key, value):
  function __main__ (line 49) | def __main__():

FILE: int_test/mapred_submitter/mr/map_reduce_combiner.py
  class Mapper (line 25) | class Mapper(api.Mapper):
    method map (line 27) | def map(self, context):
  class Reducer (line 32) | class Reducer(api.Reducer):
    method reduce (line 34) | def reduce(self, context):
  function __main__ (line 38) | def __main__():

FILE: int_test/mapred_submitter/mr/map_reduce_java_rw.py
  class Mapper (line 25) | class Mapper(api.Mapper):
    method map (line 27) | def map(self, context):
  class Reducer (line 32) | class Reducer(api.Reducer):
    method reduce (line 34) | def reduce(self, context):
  function __main__ (line 38) | def __main__():

FILE: int_test/mapred_submitter/mr/map_reduce_java_rw_pstats.py
  class Mapper (line 25) | class Mapper(api.Mapper):
    method map (line 27) | def map(self, context):
  class Reducer (line 32) | class Reducer(api.Reducer):
    method reduce (line 34) | def reduce(self, context):
  function __main__ (line 38) | def __main__():

FILE: int_test/mapred_submitter/mr/map_reduce_python_partitioner.py
  class Mapper (line 27) | class Mapper(api.Mapper):
    method map (line 29) | def map(self, context):
  class Reducer (line 34) | class Reducer(api.Reducer):
    method reduce (line 36) | def reduce(self, context):
  class Partitioner (line 40) | class Partitioner(api.Partitioner):
    method partition (line 42) | def partition(self, key, n_reduces):
  function __main__ (line 46) | def __main__():

FILE: int_test/mapred_submitter/mr/map_reduce_python_reader.py
  class Mapper (line 28) | class Mapper(api.Mapper):
    method map (line 30) | def map(self, context):
  class Reducer (line 35) | class Reducer(api.Reducer):
    method reduce (line 37) | def reduce(self, context):
  class Reader (line 41) | class Reader(api.RecordReader):
    method __init__ (line 43) | def __init__(self, context):
    method close (line 53) | def close(self):
    method next (line 56) | def next(self):
    method get_progress (line 66) | def get_progress(self):
  function __main__ (line 70) | def __main__():

FILE: int_test/mapred_submitter/mr/map_reduce_python_writer.py
  class Mapper (line 28) | class Mapper(api.Mapper):
    method map (line 30) | def map(self, context):
  class Reducer (line 35) | class Reducer(api.Reducer):
    method reduce (line 37) | def reduce(self, context):
  class Writer (line 41) | class Writer(api.RecordWriter):
    method __init__ (line 43) | def __init__(self, context):
    method close (line 49) | def close(self):
    method emit (line 52) | def emit(self, key, value):
  function __main__ (line 56) | def __main__():

FILE: int_test/mapred_submitter/mr/map_reduce_raw_io.py
  class Mapper (line 25) | class Mapper(api.Mapper):
    method map (line 29) | def map(self, context):
  class Reducer (line 36) | class Reducer(api.Reducer):
    method reduce (line 38) | def reduce(self, context):
  function __main__ (line 43) | def __main__():

FILE: int_test/mapred_submitter/mr/map_reduce_slow_java_rw.py
  class Mapper (line 28) | class Mapper(api.Mapper):
    method __init__ (line 30) | def __init__(self, context):
    method map (line 34) | def map(self, context):
    method close (line 40) | def close(self):
  class Reducer (line 44) | class Reducer(api.Reducer):
    method __init__ (line 46) | def __init__(self, context):
    method reduce (line 50) | def reduce(self, context):
    method close (line 55) | def close(self):
  function __main__ (line 59) | def __main__():

FILE: int_test/mapred_submitter/mr/map_reduce_slow_python_rw.py
  class Mapper (line 33) | class Mapper(api.Mapper):
    method __init__ (line 35) | def __init__(self, context):
    method map (line 39) | def map(self, context):
    method close (line 45) | def close(self):
  class Reducer (line 49) | class Reducer(api.Reducer):
    method __init__ (line 51) | def __init__(self, context):
    method reduce (line 55) | def reduce(self, context):
    method close (line 60) | def close(self):
  class Reader (line 64) | class Reader(api.RecordReader):
    method __init__ (line 66) | def __init__(self, context):
    method close (line 76) | def close(self):
    method next (line 79) | def next(self):
    method get_progress (line 89) | def get_progress(self):
  class Writer (line 93) | class Writer(api.RecordWriter):
    method __init__ (line 95) | def __init__(self, context):
    method close (line 101) | def close(self):
    method emit (line 104) | def emit(self, key, value):
  function __main__ (line 108) | def __main__():

FILE: int_test/opaque_split/check.py
  function check_output (line 29) | def check_output(mr_out_dir):

FILE: int_test/opaque_split/gen_splits.py
  function gen_ranges (line 32) | def gen_ranges():

FILE: int_test/opaque_split/mrapp.py
  class Reader (line 44) | class Reader(api.RecordReader):
    method __init__ (line 46) | def __init__(self, context):
    method next (line 53) | def next(self):
    method get_progress (line 57) | def get_progress(self):
  class Mapper (line 62) | class Mapper(api.Mapper):
    method map (line 64) | def map(self, context):
  function __main__ (line 68) | def __main__():

FILE: int_test/progress/mrapp.py
  class Mapper (line 28) | class Mapper(api.Mapper):
    method map (line 30) | def map(self, context):
  class Writer (line 36) | class Writer(api.RecordWriter):
    method __init__ (line 38) | def __init__(self, context):
    method close (line 46) | def close(self):
    method emit (line 49) | def emit(self, key, value):
  function __main__ (line 56) | def __main__():

FILE: pydoop/__init__.py
  function reset (line 62) | def reset():
  function hadoop_home (line 66) | def hadoop_home():
  function hadoop_conf (line 70) | def hadoop_conf():
  function hadoop_params (line 74) | def hadoop_params():
  function hadoop_classpath (line 78) | def hadoop_classpath():
  function package_dir (line 82) | def package_dir():
  function jar_name (line 92) | def jar_name(hadoop_vinfo=None):
  function jar_path (line 96) | def jar_path(hadoop_vinfo=None):
  function complete_mod_name (line 104) | def complete_mod_name(module, hadoop_vinfo=None):
  function import_version_specific_module (line 108) | def import_version_specific_module(name):
  class AddSectionWrapper (line 119) | class AddSectionWrapper(object):
    method __init__ (line 123) | def __init__(self, f):
    method __iter__ (line 127) | def __iter__(self):
    method __next__ (line 130) | def __next__(self):
    method readline (line 136) | def readline(self):
  function read_properties (line 146) | def read_properties(fname):
  class LocalModeNotSupported (line 159) | class LocalModeNotSupported(RuntimeError):
    method __init__ (line 160) | def __init__(self):
  function check_local_mode (line 165) | def check_local_mode():

FILE: pydoop/app/argparse_types.py
  function kv_pair (line 23) | def kv_pair(s):
  class UpdateMap (line 31) | class UpdateMap(argparse.Action):
    method __init__ (line 42) | def __init__(self, option_strings, dest, **kwargs):
    method __call__ (line 47) | def __call__(self, parser, namespace, values, option_string=None):
  function a_file_that_can_be_read (line 53) | def a_file_that_can_be_read(x):
  function a_hdfs_file (line 59) | def a_hdfs_file(x):
  function a_comma_separated_list (line 64) | def a_comma_separated_list(x):

FILE: pydoop/app/main.py
  class PatchedArgumentParser (line 39) | class PatchedArgumentParser(argparse.ArgumentParser):
    method _read_args_from_files (line 45) | def _read_args_from_files(self, arg_strings):
  function make_parser (line 54) | def make_parser():
  function main (line 72) | def main(argv=None):

FILE: pydoop/app/script.py
  class PydoopScript (line 45) | class PydoopScript(object):
    method __init__ (line 47) | def __init__(self, args, unknown_args):
    method generate_driver (line 53) | def generate_driver(mr_module, args):
    method convert_args (line 64) | def convert_args(self, args, unknown_args):
    method run (line 112) | def run(self):
    method clean (line 122) | def clean(self):
  function run (line 126) | def run(args, unknown_args=None):
  function add_parser_arguments (line 135) | def add_parser_arguments(parser):
  function add_parser (line 151) | def add_parser(subparsers):

FILE: pydoop/app/submit.py
  class PydoopSubmitter (line 54) | class PydoopSubmitter(object):
    method __init__ (line 60) | def __init__(self):
    method __cache_archive_link (line 80) | def __cache_archive_link(archive_name):
    method __set_files_to_cache_helper (line 84) | def __set_files_to_cache_helper(self, prop, upload_and_cache, cache):
    method __set_files_to_cache (line 103) | def __set_files_to_cache(self, args):
    method __set_archives_to_cache (line 110) | def __set_archives_to_cache(self, args):
    method _env_arg_to_dict (line 120) | def _env_arg_to_dict(set_env_list):
    method set_args (line 132) | def set_args(self, args, unknown_args=None):
    method __warn_user_if_wd_maybe_unreadable (line 163) | def __warn_user_if_wd_maybe_unreadable(self, abs_remote_path):
    method _generate_pipes_code (line 201) | def _generate_pipes_code(self):
    method __validate (line 272) | def __validate(self):
    method __clean_wd (line 282) | def __clean_wd(self):
    method __setup_remote_paths (line 292) | def __setup_remote_paths(self):
    method run (line 324) | def run(self):
    method fake_run_class (line 384) | def fake_run_class(self, *args, **kwargs):
  function run (line 391) | def run(args, unknown_args=None):
  function add_parser_common_arguments (line 400) | def add_parser_common_arguments(parser):
  function add_parser_arguments (line 481) | def add_parser_arguments(parser):
  function add_parser (line 550) | def add_parser(subparsers):

FILE: pydoop/avrolib.py
  class Deserializer (line 39) | class Deserializer(object):
    method __init__ (line 41) | def __init__(self, schema_str):
    method deserialize (line 45) | def deserialize(self, rec_bytes):
  class Serializer (line 49) | class Serializer(object):
    method __init__ (line 51) | def __init__(self, schema_str):
    method serialize (line 55) | def serialize(self, record):
  class SeekableDataFileReader (line 73) | class SeekableDataFileReader(DataFileReader):
    method align_after (line 77) | def align_after(self, offset):
  class AvroReader (line 102) | class AvroReader(RecordReader):
    method __init__ (line 108) | def __init__(self, ctx):
    method next (line 117) | def next(self):
    method get_progress (line 124) | def get_progress(self):
  class AvroWriter (line 135) | class AvroWriter(RecordWriter):
    method __init__ (line 139) | def __init__(self, context):
    method close (line 148) | def close(self):

FILE: pydoop/hadoop_utils.py
  class HadoopXMLError (line 35) | class HadoopXMLError(Exception):
  function extract_text (line 39) | def extract_text(node):
  function parse_hadoop_conf_file (line 45) | def parse_hadoop_conf_file(fn):
  class PathFinder (line 67) | class PathFinder(object):
    method __init__ (line 71) | def __init__(self):
    method reset (line 78) | def reset(self):
    method hadoop_home (line 82) | def hadoop_home(self):
    method hadoop_conf (line 95) | def hadoop_conf(self):
    method hadoop_params (line 110) | def hadoop_params(self):
    method hadoop_classpath (line 123) | def hadoop_classpath(self):
    method __get_is_local (line 134) | def __get_is_local(self):
    method is_local (line 144) | def is_local(self):

FILE: pydoop/hadut.py
  function _pop_generic_args (line 43) | def _pop_generic_args(args):
  function _merge_csv_args (line 59) | def _merge_csv_args(args):
  function _construct_property_args (line 79) | def _construct_property_args(prop_dict):
  class RunCmdError (line 84) | class RunCmdError(RuntimeError):
    method __init__ (line 89) | def __init__(self, returncode, cmd, output=None):
    method __str__ (line 94) | def __str__(self):
  function run_tool_cmd (line 105) | def run_tool_cmd(tool, cmd, args=None, properties=None, hadoop_conf_dir=...
  function run_cmd (line 155) | def run_cmd(cmd, args=None, properties=None, hadoop_home=None,
  function run_class (line 167) | def run_class(class_name, args=None, properties=None, classpath=None,
  function iter_mr_out_files (line 209) | def iter_mr_out_files(mr_out_dir):
  function collect_output (line 215) | def collect_output(mr_out_dir, out_file=None):

FILE: pydoop/hdfs/__init__.py
  function init (line 83) | def init():
  function reset (line 92) | def reset():
  function open (line 101) | def open(hdfs_path, mode="r", buff_size=0, replication=0, blocksize=0,
  function dump (line 116) | def dump(data, hdfs_path, **kwargs):
  function load (line 133) | def load(hdfs_path, **kwargs):
  function _cp_file (line 149) | def _cp_file(src_fs, src_path, dest_fs, dest_path, **kwargs):
  function cp (line 164) | def cp(src_hdfs_path, dest_hdfs_path, **kwargs):
  function put (line 220) | def put(src_path, dest_hdfs_path, **kwargs):
  function get (line 232) | def get(src_hdfs_path, dest_path, **kwargs):
  function mkdir (line 244) | def mkdir(hdfs_path, user=None):
  function rm (line 255) | def rm(hdfs_path, recursive=True, user=None):
  function rmr (line 270) | def rmr(hdfs_path, user=None):
  function lsl (line 274) | def lsl(hdfs_path, user=None, recursive=False):
  function ls (line 300) | def ls(hdfs_path, user=None, recursive=False):
  function chmod (line 311) | def chmod(hdfs_path, mode, user=None):
  function move (line 327) | def move(src, dest, user=None):
  function chown (line 343) | def chown(hdfs_path, user=None, group=None, hdfs_user=None):
  function rename (line 354) | def rename(from_path, to_path, user=None):
  function renames (line 368) | def renames(from_path, to_path, user=None):

FILE: pydoop/hdfs/common.py
  function parse_mode (line 45) | def parse_mode(mode):
  function encode_path (line 60) | def encode_path(path):
  function decode_path (line 63) | def decode_path(path):
  function encode_host (line 66) | def encode_host(host):
  function decode_host (line 69) | def decode_host(host):
  function encode_path (line 72) | def encode_path(path):
  function decode_path (line 77) | def decode_path(path):
  function encode_host (line 82) | def encode_host(host):
  function decode_host (line 87) | def decode_host(host):
  function get_groups (line 93) | def get_groups(user=DEFAULT_USER):

FILE: pydoop/hdfs/core/__init__.py
  function init (line 26) | def init():
  function core_hdfs_fs (line 38) | def core_hdfs_fs(host, port, user):

FILE: pydoop/hdfs/file.py
  function _complain_ifclosed (line 31) | def _complain_ifclosed(closed):
  class FileIO (line 36) | class FileIO(object):
    method __init__ (line 47) | def __init__(self, raw_hdfs_file, fs, mode, encoding=None, errors=None):
    method __enter__ (line 76) | def __enter__(self):
    method __exit__ (line 79) | def __exit__(self, exc_type, exc_value, traceback):
    method fs (line 83) | def fs(self):
    method name (line 90) | def name(self):
    method size (line 97) | def size(self):
    method writable (line 104) | def writable(self):
    method readline (line 107) | def readline(self):
    method next (line 122) | def next(self):
    method __next__ (line 129) | def __next__(self):
    method __iter__ (line 140) | def __iter__(self):
    method available (line 143) | def available(self):
    method close (line 154) | def close(self):
    method pread (line 165) | def pread(self, position, length):
    method read (line 188) | def read(self, length=-1):
    method seek (line 218) | def seek(self, position, whence=os.SEEK_SET):
    method tell (line 232) | def tell(self):
    method write (line 242) | def write(self, data):
    method flush (line 258) | def flush(self):
  class hdfs_file (line 266) | class hdfs_file(FileIO):
    method pread_chunk (line 268) | def pread_chunk(self, position, chunk):
    method read_chunk (line 286) | def read_chunk(self, chunk):
  class local_file (line 301) | class local_file(io.FileIO):
    method __init__ (line 309) | def __init__(self, fs, name, mode):
    method __make_parents (line 320) | def __make_parents(fs, name):
    method fs (line 329) | def fs(self):
    method size (line 333) | def size(self):
    method available (line 336) | def available(self):
    method close (line 340) | def close(self):
    method seek (line 347) | def seek(self, position, whence=os.SEEK_SET):
    method __seek_and_read (line 352) | def __seek_and_read(self, position, length=None, buf=None):
    method pread (line 366) | def pread(self, position, length):
    method pread_chunk (line 369) | def pread_chunk(self, position, chunk):
    method read_chunk (line 372) | def read_chunk(self, chunk):
  class TextIOWrapper (line 377) | class TextIOWrapper(io.TextIOWrapper):
    method __getattr__ (line 379) | def __getattr__(self, name):
    method pread (line 390) | def pread(self, position, length):

FILE: pydoop/hdfs/fs.py
  class _FSStatus (line 45) | class _FSStatus(object):
    method __init__ (line 47) | def __init__(self, fs, host, port, user, refcount=1):
    method __repr__ (line 54) | def __repr__(self):
  function _complain_ifclosed (line 58) | def _complain_ifclosed(closed):
  function _get_ip (line 63) | def _get_ip(host, default=None):
  function _get_connection_info (line 71) | def _get_connection_info(host, port, user):
  function _default_fs (line 92) | def _default_fs():
  function default_is_local (line 98) | def default_is_local():
  class hdfs (line 108) | class hdfs(object):
    method __canonize_hpu (line 134) | def __canonize_hpu(self, hpu):
    method __lookup (line 141) | def __lookup(self, hpu):
    method __eq__ (line 146) | def __eq__(self, other):
    method __init__ (line 153) | def __init__(self, host="default", port=0, user=None, groups=None):
    method __enter__ (line 187) | def __enter__(self):
    method __exit__ (line 190) | def __exit__(self, exc_type, exc_value, traceback):
    method fs (line 194) | def fs(self):
    method refcount (line 198) | def refcount(self):
    method host (line 202) | def host(self):
    method port (line 209) | def port(self):
    method user (line 216) | def user(self):
    method close (line 222) | def close(self):
    method closed (line 234) | def closed(self):
    method open_file (line 237) | def open_file(self, path,
    method capacity (line 284) | def capacity(self):
    method copy (line 296) | def copy(self, from_path, to_hdfs, to_path):
    method create_directory (line 313) | def create_directory(self, path):
    method default_block_size (line 325) | def default_block_size(self):
    method delete (line 335) | def delete(self, path, recursive=True):
    method exists (line 350) | def exists(self, path):
    method get_hosts (line 362) | def get_hosts(self, path, start, length):
    method get_path_info (line 380) | def get_path_info(self, path):
    method list_directory (line 407) | def list_directory(self, path):
    method move (line 420) | def move(self, from_path, to_hdfs, to_path):
    method rename (line 437) | def rename(self, from_path, to_path):
    method set_replication (line 450) | def set_replication(self, path, replication):
    method set_working_directory (line 463) | def set_working_directory(self, path):
    method used (line 475) | def used(self):
    method working_directory (line 485) | def working_directory(self):
    method chown (line 496) | def chown(self, path, user='', group=''):
    method __get_umask (line 512) | def __get_umask():
    method __compute_mode_from_string (line 517) | def __compute_mode_from_string(self, path, mode_string):
    method chmod (line 580) | def chmod(self, path, mode):
    method utime (line 597) | def utime(self, path, mtime, atime):
    method walk (line 612) | def walk(self, top):

FILE: pydoop/hdfs/path.py
  class StatResult (line 35) | class StatResult(object):
    method __init__ (line 49) | def __init__(self, path_info):
    method __repr__ (line 72) | def __repr__(self):
  class _HdfsPathSplitter (line 81) | class _HdfsPathSplitter(object):
    method raise_bad_path (line 86) | def raise_bad_path(cls, hdfs_path, why=None):
    method parse (line 92) | def parse(cls, hdfs_path):
    method unparse (line 118) | def unparse(cls, scheme, netloc, path):
    method split_netloc (line 132) | def split_netloc(cls, netloc):
    method split (line 150) | def split(cls, hdfs_path, user):
  function parse (line 173) | def parse(hdfs_path):
  function unparse (line 185) | def unparse(scheme, netloc, path):
  function split (line 192) | def split(hdfs_path, user=None):
  function join (line 208) | def join(*parts):
  function abspath (line 242) | def abspath(hdfs_path, user=None, local=False):
  function splitpath (line 281) | def splitpath(hdfs_path):
  function basename (line 289) | def basename(hdfs_path):
  function dirname (line 296) | def dirname(hdfs_path):
  function exists (line 304) | def exists(hdfs_path, user=None):
  function lstat (line 316) | def lstat(hdfs_path, user=None):
  function lexists (line 320) | def lexists(hdfs_path, user=None):
  function kind (line 325) | def kind(path, user=None):
  function isdir (line 341) | def isdir(path, user=None):
  function isfile (line 348) | def isfile(path, user=None):
  function expanduser (line 355) | def expanduser(path):
  function expandvars (line 371) | def expandvars(path):
  function _update_stat (line 378) | def _update_stat(st, path_):
  function stat (line 389) | def stat(path, user=None):
  function getatime (line 403) | def getatime(path, user=None):
  function getmtime (line 410) | def getmtime(path, user=None):
  function getctime (line 417) | def getctime(path, user=None):
  function getsize (line 424) | def getsize(path, user=None):
  function isfull (line 431) | def isfull(path):
  function isabs (line 441) | def isabs(path):
  function islink (line 452) | def islink(path, user=None):
  function ismount (line 464) | def ismount(path):
  function normcase (line 476) | def normcase(path):
  function normpath (line 480) | def normpath(path):
  function realpath (line 488) | def realpath(path):
  function samefile (line 500) | def samefile(path1, path2, user=None):
  function splitdrive (line 509) | def splitdrive(path):
  function splitext (line 513) | def splitext(path):
  function access (line 520) | def access(path, mode, user=None):
  function utime (line 544) | def utime(hdfs_path, times=None, user=None):

FILE: pydoop/jc.py
  function jc_wrapper (line 24) | def jc_wrapper(obj):

FILE: pydoop/mapreduce/api.py
  class JobConf (line 35) | class JobConf(dict):
    method get_int (line 48) | def get_int(self, key, default=None):
    method get_float (line 55) | def get_float(self, key, default=None):
    method get_bool (line 62) | def get_bool(self, key, default=None):
    method get_json (line 83) | def get_json(self, key, default=None):
  class InputSplit (line 88) | class InputSplit(object):
  class FileSplit (line 98) | class FileSplit(InputSplit,
  class OpaqueSplit (line 106) | class OpaqueSplit(InputSplit, namedtuple("OpaqueSplit", "payload")):
  class Context (line 124) | class Context(ABC):
    method input_split (line 139) | def input_split(self):
    method get_input_split (line 152) | def get_input_split(self, raw=False):
    method job_conf (line 156) | def job_conf(self):
    method get_job_conf (line 163) | def get_job_conf(self):
    method key (line 167) | def key(self):
    method get_input_key (line 174) | def get_input_key(self):
    method value (line 178) | def value(self):
    method get_input_value (line 185) | def get_input_value(self):
    method values (line 189) | def values(self):
    method get_input_values (line 196) | def get_input_values(self):
    method emit (line 200) | def emit(self, key, value):
    method progress (line 207) | def progress(self):
    method set_status (line 211) | def set_status(self, status):
    method get_counter (line 221) | def get_counter(self, group, name):
    method increment_counter (line 235) | def increment_counter(self, counter, amount):
  class Closable (line 242) | class Closable(object):
    method close (line 244) | def close(self):
  class Component (line 253) | class Component(ABC):
    method __init__ (line 255) | def __init__(self, context):
  class Mapper (line 259) | class Mapper(Component, Closable):
    method map (line 265) | def map(self, context):
  class Reducer (line 279) | class Reducer(Component, Closable):
    method reduce (line 286) | def reduce(self, context):
  class Combiner (line 299) | class Combiner(Reducer):
  class Partitioner (line 315) | class Partitioner(Component):
    method partition (line 326) | def partition(self, key, num_of_reduces):
  class RecordReader (line 342) | class RecordReader(Component, Closable):
    method __iter__ (line 347) | def __iter__(self):
    method next (line 351) | def next(self):
    method __next__ (line 364) | def __next__(self):
    method get_progress (line 368) | def get_progress(self):
  class RecordWriter (line 379) | class RecordWriter(Component, Closable):
    method emit (line 385) | def emit(self, key, value):
  class Factory (line 397) | class Factory(ABC):
    method create_mapper (line 414) | def create_mapper(self, context):
    method create_reducer (line 417) | def create_reducer(self, context):
    method create_combiner (line 420) | def create_combiner(self, context):
    method create_partitioner (line 428) | def create_partitioner(self, context):
    method create_record_reader (line 437) | def create_record_reader(self, context):
    method create_record_writer (line 446) | def create_record_writer(self, context):

FILE: pydoop/mapreduce/binary_protocol.py
  function get_password (line 85) | def get_password():
  function _get_LongWritable (line 97) | def _get_LongWritable(downlink):
  function _get_Text (line 102) | def _get_Text(downlink):
  function _get_avro_key (line 112) | def _get_avro_key(downlink):
  function _get_avro_value (line 117) | def _get_avro_value(downlink):
  function _get_pickled (line 122) | def _get_pickled(downlink):
  class Downlink (line 126) | class Downlink(object):
    method __init__ (line 183) | def __init__(self, istream, context, **kwargs):
    method close (line 193) | def close(self):
    method read_job_conf (line 196) | def read_job_conf(self):
    method verify_digest (line 203) | def verify_digest(self, digest, challenge):
    method setup_record_writer (line 209) | def setup_record_writer(self, piped_output):
    method get_k (line 216) | def get_k(self):
    method get_v (line 219) | def get_v(self):
    method setup_avro_deser (line 222) | def setup_avro_deser(self):
    method setup_deser (line 240) | def setup_deser(self, key_type, value_type):
    method __next__ (line 250) | def __next__(self):
    method __iter__ (line 343) | def __iter__(self):
    method next (line 347) | def next(self):
  class Uplink (line 351) | class Uplink(object):
    method __init__ (line 356) | def __init__(self, stream):
    method flush (line 359) | def flush(self):
    method close (line 362) | def close(self):
    method authenticate (line 367) | def authenticate(self, response_digest):
    method output (line 370) | def output(self, k, v):
    method partitioned_output (line 373) | def partitioned_output(self, part, k, v):
    method status (line 376) | def status(self, msg):
    method progress (line 379) | def progress(self, p):
    method done (line 382) | def done(self):
    method register_counter (line 385) | def register_counter(self, id, group, name):
    method increment_counter (line 388) | def increment_counter(self, id, amount):

FILE: pydoop/mapreduce/connections.py
  class Connection (line 38) | class Connection(object):
    method __init__ (line 56) | def __init__(self, context, istream, ostream, **kwargs):
    method close (line 60) | def close(self):
    method __enter__ (line 64) | def __enter__(self):
    method __exit__ (line 67) | def __exit__(self, *args):
  class NetworkConnection (line 71) | class NetworkConnection(Connection):
    method __init__ (line 73) | def __init__(self, context, host, port, **kwargs):
    method close (line 82) | def close(self):
  class FileConnection (line 87) | class FileConnection(Connection):
    method __init__ (line 89) | def __init__(self, context, in_fn, out_fn, **kwargs):
  function get_connection (line 97) | def get_connection(context, **kwargs):

FILE: pydoop/mapreduce/pipes.py
  function create_digest (line 60) | def create_digest(key, msg):
  function read_int_writable (line 67) | def read_int_writable(f):
  function write_int_writable (line 72) | def write_int_writable(n, f):
  function read_bytes_writable (line 76) | def read_bytes_writable(f):
  function write_bytes_writable (line 84) | def write_bytes_writable(s, f):
  class FileSplit (line 90) | class FileSplit(api.FileSplit):
    method frombuffer (line 93) | def frombuffer(cls, buf):
  class OpaqueSplit (line 98) | class OpaqueSplit(api.OpaqueSplit):
    method frombuffer (line 101) | def frombuffer(cls, buf):
    method read (line 105) | def read(cls, f):
    method write (line 108) | def write(self, f):
  function write_opaque_splits (line 112) | def write_opaque_splits(splits, f):
  function read_opaque_splits (line 118) | def read_opaque_splits(f):
  class TaskContext (line 123) | class TaskContext(api.Context):
    method __init__ (line 129) | def __init__(self, factory, **kwargs):
    method get_input_split (line 159) | def get_input_split(self, raw=False):
    method get_job_conf (line 169) | def get_job_conf(self):
    method get_input_key (line 172) | def get_input_key(self):
    method get_input_value (line 175) | def get_input_value(self):
    method get_input_values (line 178) | def get_input_values(self):
    method create_combiner (line 181) | def create_combiner(self):
    method create_mapper (line 190) | def create_mapper(self):
    method create_partitioner (line 194) | def create_partitioner(self):
    method create_record_reader (line 198) | def create_record_reader(self):
    method create_record_writer (line 202) | def create_record_writer(self):
    method create_reducer (line 206) | def create_reducer(self):
    method progress (line 210) | def progress(self):
    method set_status (line 227) | def set_status(self, status):
    method get_counter (line 231) | def get_counter(self, group, name):
    method increment_counter (line 238) | def increment_counter(self, counter, amount):
    method __spill_counters (line 244) | def __spill_counters(self):
    method _authenticate (line 250) | def _authenticate(self, password, digest, challenge):
    method _setup_avro_ser (line 257) | def _setup_avro_ser(self):
    method __maybe_serialize (line 273) | def __maybe_serialize(self, key, value):
    method emit (line 286) | def emit(self, key, value):
    method __actual_emit (line 309) | def __actual_emit(self, key, value):
    method __spill_all (line 320) | def __spill_all(self):
    method close (line 330) | def close(self):
    method get_output_dir (line 352) | def get_output_dir(self):
    method get_work_path (line 355) | def get_work_path(self):
    method get_task_partition (line 361) | def get_task_partition(self):
    method get_default_work_file (line 364) | def get_default_work_file(self, extension=""):
  class Factory (line 374) | class Factory(api.Factory):
    method __init__ (line 376) | def __init__(self, mapper_class,
    method create_mapper (line 389) | def create_mapper(self, context):
    method create_reducer (line 392) | def create_reducer(self, context):
    method create_combiner (line 395) | def create_combiner(self, context):
    method create_partitioner (line 398) | def create_partitioner(self, context):
    method create_record_reader (line 401) | def create_record_reader(self, context):
    method create_record_writer (line 404) | def create_record_writer(self, context):
  function _run (line 408) | def _run(context, **kwargs):
  function run_task (line 414) | def run_task(factory, **kwargs):

FILE: pydoop/test_support.py
  function __inject_pos (line 33) | def __inject_pos(code, start=0):
  function inject_code (line 45) | def inject_code(new_code, target_code):
  function add_sys_path (line 59) | def add_sys_path(target_code):
  function set_python_cmd (line 67) | def set_python_cmd(code, python_cmd=sys.executable):
  function adapt_script (line 77) | def adapt_script(code, python_cmd=sys.executable):
  function parse_mr_output (line 81) | def parse_mr_output(output, vtype=str):
  function compare_counts (line 97) | def compare_counts(c1, c2):
  class LocalWordCount (line 111) | class LocalWordCount(object):
    method __init__ (line 113) | def __init__(self, input_path, min_occurrence=0, stop_words=None):
    method expected_output (line 120) | def expected_output(self):
    method run (line 125) | def run(self):
    method _wordcount_file (line 138) | def _wordcount_file(self, wc, fn, path=None):
    method check (line 145) | def check(self, output):
  function get_wd_prefix (line 155) | def get_wd_prefix(base="pydoop_"):

FILE: pydoop/test_utils.py
  function _get_special_chr (line 49) | def _get_special_chr():
  class FSTree (line 83) | class FSTree(object):
    method __init__ (line 99) | def __init__(self, name, kind=1):
    method add (line 106) | def add(self, name, kind=1):
    method walk (line 111) | def walk(self):
  function make_wd (line 119) | def make_wd(fs, prefix="pydoop_test_"):
  function make_random_data (line 128) | def make_random_data(size=_RANDOM_DATA_SIZE, printable=True):
  function get_bytes_per_checksum (line 134) | def get_bytes_per_checksum():
  function silent_call (line 141) | def silent_call(func, *args, **kwargs):
  function get_module (line 155) | def get_module(name, path=None):
  function compile_java (line 165) | def compile_java(java_file, classpath, opts=None):
  function run_java (line 184) | def run_java(jclass, classpath, args, wd):
  function get_java_output_stream (line 192) | def get_java_output_stream(jclass, classpath, args, wd):
  class WDTestCase (line 199) | class WDTestCase(unittest.TestCase):
    method setUp (line 201) | def setUp(self):
    method tearDown (line 204) | def tearDown(self):
    method _mkfn (line 207) | def _mkfn(self, basename):
    method _mkf (line 210) | def _mkf(self, basename, mode='w'):

FILE: pydoop/utils/jvm.py
  function get_java_home (line 37) | def get_java_home():
  function load_jvm_lib (line 74) | def load_jvm_lib(java_home=None):
  function get_include_dirs (line 85) | def get_include_dirs():
  function get_libraries (line 101) | def get_libraries():
  function get_macros (line 114) | def get_macros():
  function get_jvm_lib_path_and_name (line 125) | def get_jvm_lib_path_and_name(java_home=None):
  function check_jni_header (line 139) | def check_jni_header(include_dirs=None):
  function find_file (line 150) | def find_file(path, to_find):

FILE: pydoop/utils/misc.py
  class NullHandler (line 31) | class NullHandler(logging.Handler):
    method emit (line 32) | def emit(self, record):
  class NullLogger (line 36) | class NullLogger(logging.Logger):
    method __init__ (line 37) | def __init__(self):
  function make_random_str (line 43) | def make_random_str(prefix="pydoop_", postfix=''):
  class Timer (line 47) | class Timer(object):
    method __init__ (line 49) | def __init__(self, ctx, counter_group=None):
    method _gen_counter_name (line 55) | def _gen_counter_name(self, event):
    method _get_time_counter (line 58) | def _get_time_counter(self, name):
    method start (line 66) | def start(self, s):
    method stop (line 69) | def stop(self, s):
    method time_block (line 73) | def time_block(self, event_name):
    class TimingBlock (line 76) | class TimingBlock(object):
      method __init__ (line 78) | def __init__(self, timer, event_name):
      method __enter__ (line 82) | def __enter__(self):
      method __exit__ (line 86) | def __exit__(self, exception_type, exception_val, exception_tb):

FILE: pydoop/utils/py3compat.py
  class Py2ABC (line 43) | class Py2ABC(object):
  function __identity (line 47) | def __identity(x):
  function __chr (line 51) | def __chr(x):
  function __iteritems_2 (line 55) | def __iteritems_2(x):
  function __iteritems_3 (line 59) | def __iteritems_3(x):
  function __parser_read_2 (line 63) | def __parser_read_2(parser, f):
  function __parser_read_3 (line 67) | def __parser_read_3(parser, f):

FILE: setup.py
  function rm_rf (line 90) | def rm_rf(path, dry_run=False):
  function mtime (line 108) | def mtime(fn):
  function must_generate (line 112) | def must_generate(target, prerequisites):
  function get_version_string (line 119) | def get_version_string():
  function write_config (line 127) | def write_config(filename="pydoop/config.py"):
  function write_version (line 137) | def write_version(filename="pydoop/version.py"):
  class JavaLib (line 179) | class JavaLib(object):
    method __init__ (line 181) | def __init__(self):
  class JavaBuilder (line 194) | class JavaBuilder(object):
    method __init__ (line 196) | def __init__(self, build_temp, build_lib):
    method run (line 201) | def run(self):
    method __build_java_lib (line 205) | def __build_java_lib(self, jlib):
  class BuildPydoopExt (line 251) | class BuildPydoopExt(build_ext):
    method __have_better_tls (line 253) | def __have_better_tls(self):
    method __finalize_hdfs (line 269) | def __finalize_hdfs(self, ext):
    method build_extension (line 292) | def build_extension(self, ext):
  class BuildPydoop (line 298) | class BuildPydoop(build):
    method build_java (line 300) | def build_java(self):
    method create_tmp (line 304) | def create_tmp(self):
    method clean_up (line 310) | def clean_up(self):
    method run (line 313) | def run(self):

FILE: src/it/crs4/pydoop/NoSeparatorTextOutputFormat.java
  class NoSeparatorTextOutputFormat (line 41) | public class NoSeparatorTextOutputFormat extends TextOutputFormat<Text, ...
    method getRecordWriter (line 43) | public RecordWriter<Text, Text>

FILE: src/it/crs4/pydoop/mapreduce/pipes/Application.java
  class Application (line 74) | class Application<K1 extends Writable, V1 extends Writable,
    method Application (line 90) | Application(TaskInputOutputContext<K1,V1,K2,V2> context,
    method getSecurityChallenge (line 163) | private String getSecurityChallenge() {
    method writePasswordToLocalFile (line 174) | private void writePasswordToLocalFile(String localPasswordFile,
    method getDownlink (line 190) | DownwardProtocol<K1, V1> getDownlink() {
    method waitForAuthentication (line 199) | void waitForAuthentication() throws IOException,
    method waitForFinish (line 211) | boolean waitForFinish() throws Throwable {
    method abort (line 221) | void abort(Throwable t) throws IOException {
    method cleanup (line 243) | void cleanup() throws IOException {
    method runClient (line 260) | static Process runClient(List<String> command,
    method createDigest (line 270) | public static String createDigest(byte[] password, String data)

FILE: src/it/crs4/pydoop/mapreduce/pipes/BinaryProtocol.java
  class BinaryProtocol (line 51) | class BinaryProtocol<K1 extends Writable, V1 extends Writable,
    type MessageType (line 71) | private static enum MessageType { START(0),
      method MessageType (line 91) | MessageType(int code) {
    class UplinkReaderThread (line 96) | private static class UplinkReaderThread<K2 extends WritableComparable,
      method UplinkReaderThread (line 106) | public UplinkReaderThread(InputStream stream,
      method closeConnection (line 116) | public void closeConnection() throws IOException {
      method run (line 120) | public void run() {
      method readObject (line 174) | private void readObject(Writable obj) throws IOException {
    class TeeOutputStream (line 197) | private static class TeeOutputStream extends FilterOutputStream {
      method TeeOutputStream (line 199) | TeeOutputStream(String filename, OutputStream base) throws IOExcepti...
      method write (line 203) | public void write(byte b[], int off, int len) throws IOException {
      method write (line 208) | public void write(int b) throws IOException {
      method flush (line 213) | public void flush() throws IOException {
      method close (line 218) | public void close() throws IOException {
    method BinaryProtocol (line 236) | public BinaryProtocol(Socket sock,
    method close (line 259) | public void close() throws IOException, InterruptedException {
    method authenticate (line 267) | public void authenticate(String digest, String challenge)
    method start (line 276) | public void start() throws IOException {
    method setJobConf (line 282) | public void setJobConf(Configuration conf) throws IOException {
    method setInputTypes (line 295) | public void setInputTypes(String keyType,
    method runMap (line 302) | public void runMap(InputSplit split, int numReduces,
    method mapItem (line 313) | public void mapItem(Writable key,
    method runReduce (line 320) | public void runReduce(int reduce, boolean pipedOutput) throws IOExcept...
    method reduceKey (line 326) | public void reduceKey(Writable key) throws IOException {
    method reduceValue (line 331) | public void reduceValue(Writable value) throws IOException {
    method endOfInput (line 336) | public void endOfInput() throws IOException {
    method abort (line 341) | public void abort() throws IOException {
    method flush (line 346) | public void flush() throws IOException {
    method writeObject (line 357) | private void writeObject(Writable obj) throws IOException {

FILE: src/it/crs4/pydoop/mapreduce/pipes/DownwardProtocol.java
  type DownwardProtocol (line 35) | interface DownwardProtocol<K extends Writable, V extends Writable> {
    method authenticate (line 40) | void authenticate(String digest, String challenge) throws IOException;
    method start (line 46) | void start() throws IOException;
    method setJobConf (line 53) | void setJobConf(Configuration conf) throws IOException;
    method setInputTypes (line 61) | void setInputTypes(String keyType, String valueType) throws IOException;
    method runMap (line 70) | void runMap(InputSplit split, int numReduces,
    method mapItem (line 79) | void mapItem(K key, V value) throws IOException;
    method runReduce (line 87) | void runReduce(int reduce, boolean pipedOutput) throws IOException;
    method reduceKey (line 94) | void reduceKey(K key) throws IOException;
    method reduceValue (line 101) | void reduceValue(V value) throws IOException;
    method endOfInput (line 108) | void endOfInput() throws IOException;
    method abort (line 114) | void abort() throws IOException;
    method flush (line 119) | void flush() throws IOException;
    method close (line 124) | void close() throws IOException, InterruptedException;

FILE: src/it/crs4/pydoop/mapreduce/pipes/DummyRecordReader.java
  class DummyRecordReader (line 27) | public abstract class DummyRecordReader
    method next (line 30) | public abstract  boolean next(FloatWritable key, NullWritable value)

FILE: src/it/crs4/pydoop/mapreduce/pipes/OpaqueSplit.java
  class OpaqueSplit (line 33) | class OpaqueSplit extends InputSplit implements Writable {
    method OpaqueSplit (line 37) | public OpaqueSplit() {
    method OpaqueSplit (line 41) | public OpaqueSplit(byte[] payload) {
    method getPayload (line 45) | public BytesWritable getPayload() {
    method getLength (line 49) | @Override
    method toString (line 54) | @Override
    method getLocations (line 59) | @Override
    method getLocationInfo (line 64) | @Override
    method write (line 71) | @Override
    method readFields (line 76) | @Override

FILE: src/it/crs4/pydoop/mapreduce/pipes/OutputHandler.java
  class OutputHandler (line 36) | class OutputHandler<K extends WritableComparable, V extends Writable>
    method OutputHandler (line 57) | public OutputHandler(TaskInputOutputContext context,
    method output (line 68) | @Override
    method partitionedOutput (line 76) | @Override
    method status (line 86) | @Override
    method progress (line 96) | @Override
    method done (line 109) | @Override
    method getProgress (line 121) | public float getProgress() {
    method failed (line 128) | public void failed(Throwable e) {
    method waitForFinish (line 140) | public synchronized boolean waitForFinish() throws Throwable {
    method registerCounter (line 150) | @Override
    method incrementCounter (line 156) | @Override
    method authenticate (line 166) | public synchronized boolean authenticate(String digest) throws IOExcep...
    method waitForAuthentication (line 184) | synchronized void waitForAuthentication()

FILE: src/it/crs4/pydoop/mapreduce/pipes/PipesMapper.java
  class PipesMapper (line 40) | class PipesMapper<K1 extends Writable, V1 extends Writable,
    method setup (line 50) | @Override
    method cleanup (line 60) | @Override
    method run (line 68) | @Override

FILE: src/it/crs4/pydoop/mapreduce/pipes/PipesNonJavaInputFormat.java
  class PipesNonJavaInputFormat (line 51) | class PipesNonJavaInputFormat
    method getSplits (line 54) | public List<InputSplit> getSplits(JobContext context)
    method getOpaqueSplits (line 69) | private List<InputSplit> getOpaqueSplits(Configuration conf, String uri)
    method createRecordReader (line 92) | @Override
    class PipesDummyRecordReader (line 109) | static class PipesDummyRecordReader extends DummyRecordReader {
      method PipesDummyRecordReader (line 113) | public PipesDummyRecordReader() {}
      method PipesDummyRecordReader (line 115) | public PipesDummyRecordReader(InputSplit split, TaskAttemptContext c...
      method initialize (line 120) | @Override
      method close (line 124) | public synchronized void close() throws IOException {}
      method getProgress (line 126) | @Override
      method nextKeyValue (line 131) | @Override
      method getCurrentKey (line 136) | @Override
      method getCurrentValue (line 142) | @Override
      method next (line 148) | @Override

FILE: src/it/crs4/pydoop/mapreduce/pipes/PipesNonJavaOutputFormat.java
  class PipesNonJavaOutputFormat (line 29) | public class PipesNonJavaOutputFormat<K, V> extends FileOutputFormat<K, ...
    method getRecordWriter (line 31) | @Override

FILE: src/it/crs4/pydoop/mapreduce/pipes/PipesPartitioner.java
  class PipesPartitioner (line 33) | class PipesPartitioner<K extends WritableComparable, V extends Writable>
    method setConf (line 42) | public void setConf(Configuration conf) {
    method getConf (line 48) | public Configuration getConf() {
    method setNextPartition (line 56) | static void setNextPartition(int newValue) {
    method getPartition (line 67) | @Override

FILE: src/it/crs4/pydoop/mapreduce/pipes/PipesReducer.java
  class PipesReducer (line 38) | class PipesReducer<K2 extends WritableComparable, V2 extends Writable,
    method setup (line 48) | @Override
    method reduce (line 58) | @Override
    method startApplication (line 70) | @SuppressWarnings("unchecked")
    method cleanup (line 88) | @Override

FILE: src/it/crs4/pydoop/mapreduce/pipes/PydoopAvroBridgeKeyReader.java
  class PydoopAvroBridgeKeyReader (line 37) | public class PydoopAvroBridgeKeyReader
    method PydoopAvroBridgeKeyReader (line 42) | public PydoopAvroBridgeKeyReader(
    method getInRecords (line 48) | protected List<IndexedRecord> getInRecords()
    method initialize (line 54) | public void initialize(InputSplit split, TaskAttemptContext context)
    method getCurrentKey (line 64) | @Override
    method getCurrentValue (line 71) | @Override

FILE: src/it/crs4/pydoop/mapreduce/pipes/PydoopAvroBridgeKeyValueReader.java
  class PydoopAvroBridgeKeyValueReader (line 36) | public class PydoopAvroBridgeKeyValueReader
    method PydoopAvroBridgeKeyValueReader (line 41) | public PydoopAvroBridgeKeyValueReader(
    method getInRecords (line 48) | protected List<IndexedRecord> getInRecords()
    method initialize (line 55) | public void initialize(InputSplit split, TaskAttemptContext context)
    method getCurrentKey (line 67) | @Override
    method getCurrentValue (line 74) | @Override

FILE: src/it/crs4/pydoop/mapreduce/pipes/PydoopAvroBridgeKeyValueWriter.java
  class PydoopAvroBridgeKeyValueWriter (line 33) | public class PydoopAvroBridgeKeyValueWriter
    method PydoopAvroBridgeKeyValueWriter (line 36) | public PydoopAvroBridgeKeyValueWriter(
    method write (line 43) | public void write(Text key, Text value)

FILE: src/it/crs4/pydoop/mapreduce/pipes/PydoopAvroBridgeKeyWriter.java
  class PydoopAvroBridgeKeyWriter (line 34) | public class PydoopAvroBridgeKeyWriter extends PydoopAvroBridgeWriterBase {
    method PydoopAvroBridgeKeyWriter (line 36) | public PydoopAvroBridgeKeyWriter(
    method write (line 43) | public void write(Text key, Text ignore)

FILE: src/it/crs4/pydoop/mapreduce/pipes/PydoopAvroBridgeReaderBase.java
  class PydoopAvroBridgeReaderBase (line 42) | public abstract class PydoopAvroBridgeReaderBase<K, V>
    method getInRecords (line 71) | protected abstract List<IndexedRecord> getInRecords()
    method initialize (line 74) | public void initialize(InputSplit split, TaskAttemptContext context)
    method nextKeyValue (line 105) | public synchronized boolean nextKeyValue()
    method getProgress (line 147) | public float getProgress() throws IOException,  InterruptedException {
    method close (line 151) | public synchronized void close() throws IOException {

FILE: src/it/crs4/pydoop/mapreduce/pipes/PydoopAvroBridgeValueReader.java
  class PydoopAvroBridgeValueReader (line 37) | public class PydoopAvroBridgeValueReader
    method PydoopAvroBridgeValueReader (line 42) | public PydoopAvroBridgeValueReader(
    method getInRecords (line 48) | protected List<IndexedRecord> getInRecords()
    method initialize (line 54) | public void initialize(InputSplit split, TaskAttemptContext context)
    method getCurrentKey (line 64) | @Override
    method getCurrentValue (line 70) | @Override

FILE: src/it/crs4/pydoop/mapreduce/pipes/PydoopAvroBridgeValueWriter.java
  class PydoopAvroBridgeValueWriter (line 34) | public class PydoopAvroBridgeValueWriter extends PydoopAvroBridgeWriterB...
    method PydoopAvroBridgeValueWriter (line 36) | public PydoopAvroBridgeValueWriter(
    method write (line 43) | public void write(Text ignore, Text value)

FILE: src/it/crs4/pydoop/mapreduce/pipes/PydoopAvroBridgeWriterBase.java
  class PydoopAvroBridgeWriterBase (line 46) | public abstract class PydoopAvroBridgeWriterBase
    method PydoopAvroBridgeWriterBase (line 64) | public PydoopAvroBridgeWriterBase(TaskAttemptContext context, AvroIO m...
    method getOutRecords (line 91) | protected List<GenericRecord> getOutRecords(List<Text> inRecords)
    method write (line 104) | protected void write(List<GenericRecord> outRecords)
    method close (line 126) | public void close(TaskAttemptContext context)

FILE: src/it/crs4/pydoop/mapreduce/pipes/PydoopAvroInputBridgeBase.java
  class PydoopAvroInputBridgeBase (line 32) | public abstract class PydoopAvroInputBridgeBase<K, V>
    method getActualFormat (line 38) | protected InputFormat getActualFormat(Configuration conf) {
    method getSplits (line 49) | @Override

FILE: src/it/crs4/pydoop/mapreduce/pipes/PydoopAvroInputKeyBridge.java
  class PydoopAvroInputKeyBridge (line 31) | public class PydoopAvroInputKeyBridge
    method PydoopAvroInputKeyBridge (line 34) | public PydoopAvroInputKeyBridge() {
    method createRecordReader (line 38) | @Override

FILE: src/it/crs4/pydoop/mapreduce/pipes/PydoopAvroInputKeyValueBridge.java
  class PydoopAvroInputKeyValueBridge (line 30) | public class PydoopAvroInputKeyValueBridge
    method PydoopAvroInputKeyValueBridge (line 33) | public PydoopAvroInputKeyValueBridge() {
    method createRecordReader (line 37) | @Override

FILE: src/it/crs4/pydoop/mapreduce/pipes/PydoopAvroInputValueBridge.java
  class PydoopAvroInputValueBridge (line 31) | public class PydoopAvroInputValueBridge
    method PydoopAvroInputValueBridge (line 34) | public PydoopAvroInputValueBridge() {
    method createRecordReader (line 38) | @Override

FILE: src/it/crs4/pydoop/mapreduce/pipes/PydoopAvroKeyInputFormat.java
  class PydoopAvroKeyInputFormat (line 32) | public class PydoopAvroKeyInputFormat
    method createRecordReader (line 35) | @Override

FILE: src/it/crs4/pydoop/mapreduce/pipes/PydoopAvroKeyOutputFormat.java
  class PydoopAvroKeyOutputFormat (line 30) | public class PydoopAvroKeyOutputFormat
    method getRecordWriter (line 33) | @Override

FILE: src/it/crs4/pydoop/mapreduce/pipes/PydoopAvroKeyRecordReader.java
  class PydoopAvroKeyRecordReader (line 31) | public class PydoopAvroKeyRecordReader
    method PydoopAvroKeyRecordReader (line 37) | public PydoopAvroKeyRecordReader(Schema readerSchema) {
    method getCurrentKey (line 41) | @Override
    method getCurrentValue (line 47) | @Override

FILE: src/it/crs4/pydoop/mapreduce/pipes/PydoopAvroKeyRecordWriter.java
  class PydoopAvroKeyRecordWriter (line 31) | public class PydoopAvroKeyRecordWriter
    method PydoopAvroKeyRecordWriter (line 34) | public PydoopAvroKeyRecordWriter(Schema writerSchema,
    method write (line 40) | @Override

FILE: src/it/crs4/pydoop/mapreduce/pipes/PydoopAvroKeyValueInputFormat.java
  class PydoopAvroKeyValueInputFormat (line 31) | public class PydoopAvroKeyValueInputFormat
    method createRecordReader (line 34) | @Override

FILE: src/it/crs4/pydoop/mapreduce/pipes/PydoopAvroKeyValueOutputFormat.java
  class PydoopAvroKeyValueOutputFormat (line 31) | public class PydoopAvroKeyValueOutputFormat
    method getRecordWriter (line 34) | @Override

FILE: src/it/crs4/pydoop/mapreduce/pipes/PydoopAvroKeyValueRecordReader.java
  class PydoopAvroKeyValueRecordReader (line 27) | public class PydoopAvroKeyValueRecordReader
    method PydoopAvroKeyValueRecordReader (line 30) | public PydoopAvroKeyValueRecordReader(Schema readerSchema) {
    method getCurrentKey (line 34) | @Override
    method getCurrentValue (line 40) | @Override

FILE: src/it/crs4/pydoop/mapreduce/pipes/PydoopAvroKeyValueRecordWriter.java
  class PydoopAvroKeyValueRecordWriter (line 31) | public class PydoopAvroKeyValueRecordWriter
    method PydoopAvroKeyValueRecordWriter (line 36) | public PydoopAvroKeyValueRecordWriter(Schema writerSchema,
    method write (line 43) | @Override

FILE: src/it/crs4/pydoop/mapreduce/pipes/PydoopAvroOutputBridgeBase.java
  class PydoopAvroOutputBridgeBase (line 33) | public abstract class PydoopAvroOutputBridgeBase
    method getActualFormat (line 39) | protected OutputFormat getActualFormat(Configuration conf) {
    method checkOutputSpecs (line 50) | @Override
    method getOutputCommitter (line 57) | @Override

FILE: src/it/crs4/pydoop/mapreduce/pipes/PydoopAvroOutputFormatBase.java
  class PydoopAvroOutputFormatBase (line 31) | public abstract class PydoopAvroOutputFormatBase<K, V>
    method getOutputSchema (line 34) | protected static Schema getOutputSchema(

FILE: src/it/crs4/pydoop/mapreduce/pipes/PydoopAvroOutputKeyBridge.java
  class PydoopAvroOutputKeyBridge (line 30) | public class PydoopAvroOutputKeyBridge extends PydoopAvroOutputBridgeBase {
    method PydoopAvroOutputKeyBridge (line 32) | public PydoopAvroOutputKeyBridge() {
    method getRecordWriter (line 36) | @Override

FILE: src/it/crs4/pydoop/mapreduce/pipes/PydoopAvroOutputKeyValueBridge.java
  class PydoopAvroOutputKeyValueBridge (line 30) | public class PydoopAvroOutputKeyValueBridge
    method PydoopAvroOutputKeyValueBridge (line 33) | public PydoopAvroOutputKeyValueBridge() {
    method getRecordWriter (line 37) | @Override

FILE: src/it/crs4/pydoop/mapreduce/pipes/PydoopAvroOutputValueBridge.java
  class PydoopAvroOutputValueBridge (line 30) | public class PydoopAvroOutputValueBridge extends PydoopAvroOutputBridgeB...
    method PydoopAvroOutputValueBridge (line 32) | public PydoopAvroOutputValueBridge() {
    method getRecordWriter (line 36) | @Override

FILE: src/it/crs4/pydoop/mapreduce/pipes/PydoopAvroRecordReaderBase.java
  class PydoopAvroRecordReaderBase (line 41) | public abstract class PydoopAvroRecordReaderBase<K, V>
    method PydoopAvroRecordReaderBase (line 53) | protected PydoopAvroRecordReaderBase(Schema readerSchema) {
    method initialize (line 58) | @Override
    method nextKeyValue (line 77) | @Override
    method getProgress (line 87) | @Override
    method close (line 100) | @Override
    method getCurrentRecord (line 111) | protected GenericRecord getCurrentRecord() {
    method createSeekableInput (line 115) | protected SeekableInput createSeekableInput(Configuration conf, Path p...

FILE: src/it/crs4/pydoop/mapreduce/pipes/PydoopAvroRecordWriterBase.java
  class PydoopAvroRecordWriterBase (line 34) | public abstract class PydoopAvroRecordWriterBase<K, V>
    method PydoopAvroRecordWriterBase (line 39) | protected PydoopAvroRecordWriterBase(Schema writerSchema,
    method close (line 48) | @Override

FILE: src/it/crs4/pydoop/mapreduce/pipes/PydoopAvroValueInputFormat.java
  class PydoopAvroValueInputFormat (line 32) | public class PydoopAvroValueInputFormat
    method createRecordReader (line 35) | @Override

FILE: src/it/crs4/pydoop/mapreduce/pipes/PydoopAvroValueOutputFormat.java
  class PydoopAvroValueOutputFormat (line 30) | public class PydoopAvroValueOutputFormat
    method getRecordWriter (line 33) | @Override

FILE: src/it/crs4/pydoop/mapreduce/pipes/PydoopAvroValueRecordReader.java
  class PydoopAvroValueRecordReader (line 31) | public class PydoopAvroValueRecordReader
    method PydoopAvroValueRecordReader (line 37) | public PydoopAvroValueRecordReader(Schema readerSchema) {
    method getCurrentKey (line 41) | @Override
    method getCurrentValue (line 47) | @Override

FILE: src/it/crs4/pydoop/mapreduce/pipes/PydoopAvroValueRecordWriter.java
  class PydoopAvroValueRecordWriter (line 31) | public class PydoopAvroValueRecordWriter
    method PydoopAvroValueRecordWriter (line 34) | public PydoopAvroValueRecordWriter(Schema writerSchema,
    method write (line 40) | @Override

FILE: src/it/crs4/pydoop/mapreduce/pipes/Submitter.java
  class CommandLineParser (line 66) | class CommandLineParser {
    method CommandLineParser (line 69) | CommandLineParser() {
    method addOption (line 85) | void addOption(String longName, boolean required, String description,
    method addArgument (line 93) | void addArgument(String name, boolean required, String description) {
    method parse (line 100) | CommandLine parse(Configuration conf, String[] args)
    method printUsage (line 108) | void printUsage() {
  class Submitter (line 131) | public class Submitter extends Configured implements Tool {
    type AvroIO (line 133) | public static enum AvroIO {
    method getPydoopProperties (line 162) | public static Properties getPydoopProperties() {
    method Submitter (line 176) | public Submitter() {
    method isLocalFS (line 181) | public static boolean isLocalFS(Configuration conf) throws IOException {
    method getExecutable (line 190) | public static String getExecutable(Configuration conf) {
    method setExecutable (line 200) | public static void setExecutable(Configuration conf, String executable) {
    method setIsJavaRecordReader (line 209) | public static void setIsJavaRecordReader(Configuration conf, boolean v...
    method getIsJavaRecordReader (line 218) | public static boolean getIsJavaRecordReader(Configuration conf) {
    method setIsJavaMapper (line 227) | public static void setIsJavaMapper(Configuration conf, boolean value) {
    method getIsJavaMapper (line 236) | public static boolean getIsJavaMapper(Configuration conf) {
    method setIsJavaReducer (line 245) | public static void setIsJavaReducer(Configuration conf, boolean value) {
    method getIsJavaReducer (line 254) | public static boolean getIsJavaReducer(Configuration conf) {
    method setIsJavaRecordWriter (line 263) | public static void setIsJavaRecordWriter(Configuration conf, boolean v...
    method getIsJavaRecordWriter (line 272) | public static boolean getIsJavaRecordWriter(Configuration conf) {
    method setIfUnset (line 283) | private static void setIfUnset(Configuration conf, String key, String ...
    method setJavaPartitioner (line 294) | static void setJavaPartitioner(Configuration conf, Class cls) {
    method getJavaPartitioner (line 303) | static Class<? extends Partitioner> getJavaPartitioner(Configuration c...
    method getClass (line 308) | private static <InterfaceType>
    method getKeepCommandFile (line 327) | public static boolean getKeepCommandFile(Configuration conf) {
    method setKeepCommandFile (line 336) | public static void setKeepCommandFile(Configuration conf, boolean keep) {
    method setupPipesJob (line 340) | private static void setupPipesJob(Job job)
    method run (line 453) | public int run(String[] args) throws Exception {
    method main (line 548) | public static void main(String[] args) throws Exception {

FILE: src/it/crs4/pydoop/mapreduce/pipes/TaskLog.java
  class TaskLog (line 71) | @InterfaceAudience.Private
    method getYarnAppContainerLogDir (line 84) | private static String getYarnAppContainerLogDir(){
    method getMRv2LogDir (line 93) | public static String getMRv2LogDir() {
    method getTaskLogFile (line 97) | public static File getTaskLogFile(TaskAttemptID taskid, boolean isClea...
    method getRealTaskLogFileLocation (line 106) | static File getRealTaskLogFileLocation(TaskAttemptID taskid,
    class LogFileDetail (line 117) | private static class LogFileDetail {
    method getLogFileDetail (line 124) | private static LogFileDetail getLogFileDetail(TaskAttemptID taskid,
    method getTmpIndexFile (line 177) | private static File getTmpIndexFile(TaskAttemptID taskid, boolean isCl...
    method getIndexFile (line 181) | static File getIndexFile(TaskAttemptID taskid, boolean isCleanup) {
    method obtainLogDirOwner (line 189) | static String obtainLogDirOwner(TaskAttemptID taskid) throws IOExcepti...
    method getBaseLogDir (line 197) | static String getBaseLogDir() {
    method getAttemptDir (line 201) | static File getAttemptDir(TaskAttemptID taskid, boolean isCleanup) {
    method writeToIndexFile (line 209) | private static synchronized
    method resetPrevLengths (line 255) | private static void resetPrevLengths(String logLocation) {
    method syncLogs (line 262) | @SuppressWarnings("unchecked")
    method syncLogsShutdown (line 287) | public static synchronized void syncLogsShutdown(
    method syncLogs (line 303) | @SuppressWarnings("unchecked")
    method flushAppenders (line 322) | @SuppressWarnings("unchecked")
    method createLogSyncer (line 338) | public static ScheduledExecutorService createLogSyncer() {
    type LogName (line 369) | @InterfaceAudience.Private
      method LogName (line 388) | private LogName(String prefix) {
      method toString (line 392) | @Override
    class Reader (line 398) | public static class Reader extends InputStream {
      method Reader (line 414) | public Reader(TaskAttemptID taskid, LogName kind,
      method read (line 446) | @Override
      method read (line 456) | @Override
      method available (line 466) | @Override
      method close (line 471) | @Override
    method getTaskLogLength (line 485) | public static long getTaskLogLength(Configuration conf) {
    method captureOutAndError (line 503) | public static List<String> captureOutAndError(List<String> setup,
    method buildCommandLine (line 530) | static String buildCommandLine(List<String> setup, List<String> cmd,
    method buildDebugScriptCommandLine (line 593) | static String buildDebugScriptCommandLine(List<String> cmd, String deb...
    method addCommand (line 624) | public static String addCommand(List<String> cmd, boolean isExecutable)
    method getUserLogDir (line 649) | static File getUserLogDir() {
    method getJobDir (line 665) | public static File getJobDir(JobID jobid) {

FILE: src/it/crs4/pydoop/mapreduce/pipes/TaskLogAppender.java
  class TaskLogAppender (line 38) | @InterfaceStability.Unstable
    method activateOptions (line 51) | @Override
    method setOptionsFromSystemProperties (line 70) | private synchronized void setOptionsFromSystemProperties() {
    method append (line 86) | @Override
    method flush (line 100) | @Override
    method close (line 107) | @Override
    method getTaskId (line 121) | public synchronized String getTaskId() {
    method setTaskId (line 125) | public synchronized void setTaskId(String taskId) {
    method getTotalLogFileSize (line 131) | public synchronized long getTotalLogFileSize() {
    method setTotalLogFileSize (line 135) | public synchronized void setTotalLogFileSize(long logSize) {
    method setIsCleanup (line 145) | public synchronized void setIsCleanup(boolean isCleanup) {
    method getIsCleanup (line 154) | public synchronized boolean getIsCleanup() {

FILE: src/it/crs4/pydoop/mapreduce/pipes/UpwardProtocol.java
  type UpwardProtocol (line 29) | interface UpwardProtocol<K extends WritableComparable, V extends Writabl...
    method output (line 36) | void output(K key, V value) throws IOException, InterruptedException;
    method partitionedOutput (line 46) | void partitionedOutput(int reduce, K key,
    method status (line 54) | void status(String msg) throws IOException, InterruptedException;
    method progress (line 61) | void progress(float progress) throws IOException, InterruptedException;
    method done (line 68) | void done() throws IOException, InterruptedException;
    method failed (line 74) | void failed(Throwable e);
    method registerCounter (line 82) | void registerCounter(int id, String group, String name) throws IOExcep...
    method incrementCounter (line 90) | void incrementCounter(int id, long amount) throws IOException;
    method authenticate (line 99) | boolean authenticate(String digest) throws IOException;

FILE: src/libhdfs/common/htable.c
  type htable_pair (line 27) | struct htable_pair {
  type htable (line 35) | struct htable {
  function htable_insert_internal (line 54) | static void htable_insert_internal(struct htable_pair *nelem,
  function htable_realloc (line 74) | static int htable_realloc(struct htable *htable, uint32_t new_capacity)
  function round_up_to_power_of_2 (line 97) | static uint32_t round_up_to_power_of_2(uint32_t i)
  type htable (line 112) | struct htable
  type htable (line 115) | struct htable
  function htable_visit (line 135) | void htable_visit(struct htable *htable, visitor_fn_t fun, void *ctx)
  function htable_free (line 147) | void htable_free(struct htable *htable)
  function htable_put (line 155) | int htable_put(struct htable *htable, void *key, void *val)
  function htable_get_internal (line 185) | static int htable_get_internal(const struct htable *htable,
  type htable (line 213) | struct htable
  function htable_pop (line 223) | void htable_pop(struct htable *htable, const void *key,
  function htable_used (line 260) | uint32_t htable_used(const struct htable *htable)
  function htable_capacity (line 265) | uint32_t htable_capacity(const struct htable *htable)
  function ht_hash_string (line 270) | uint32_t ht_hash_string(const void *str, uint32_t max)
  function ht_compare_string (line 282) | int ht_compare_string(const void *a, const void *b)

FILE: src/libhdfs/common/htable.h
  type htable (line 28) | struct htable
  type htable (line 59) | struct htable
  type htable (line 71) | struct htable
  type htable (line 81) | struct htable
  type htable (line 96) | struct htable
  type htable (line 106) | struct htable
  type htable (line 118) | struct htable
  type htable (line 128) | struct htable
  type htable (line 137) | struct htable

FILE: src/libhdfs/exception.c
  type ExceptionInfo (line 30) | struct ExceptionInfo {
  type ExceptionInfo (line 36) | struct ExceptionInfo
  function getExceptionInfo (line 94) | void getExceptionInfo(const char *excName, int noPrintFlags,
  function printExceptionAndFreeV (line 113) | int printExceptionAndFreeV(JNIEnv *env, jthrowable exc, int noPrintFlags,
  function printExceptionAndFree (line 173) | int printExceptionAndFree(JNIEnv *env, jthrowable exc, int noPrintFlags,
  function printPendingExceptionAndFree (line 185) | int printPendingExceptionAndFree(JNIEnv *env, int noPrintFlags,
  function jthrowable (line 208) | jthrowable getPendingExceptionAndClear(JNIEnv *env)
  function jthrowable (line 217) | jthrowable newRuntimeError(JNIEnv *env, const char *fmt, ...)

FILE: src/libhdfs/hdfs.c
  type hdfsStreamType (line 66) | enum hdfsStreamType
  type hdfsFile_internal (line 76) | struct hdfsFile_internal {
  type hdfsExtendedFileInfo (line 87) | struct hdfsExtendedFileInfo {
  function hdfsFileIsOpenForRead (line 91) | int hdfsFileIsOpenForRead(hdfsFile file)
  function hdfsFileGetReadStatistics (line 96) | int hdfsFileGetReadStatistics(hdfsFile file,
  function hdfsReadStatisticsGetRemoteBytesRead (line 181) | int64_t hdfsReadStatisticsGetRemoteBytesRead(
  function hdfsFileClearReadStatistics (line 187) | int hdfsFileClearReadStatistics(hdfsFile file)
  function hdfsFileFreeReadStatistics (line 218) | void hdfsFileFreeReadStatistics(struct hdfsReadStatistics *stats)
  function hdfsFileIsOpenForWrite (line 223) | int hdfsFileIsOpenForWrite(hdfsFile file)
  function hdfsFileUsesDirectRead (line 228) | int hdfsFileUsesDirectRead(hdfsFile file)
  function hdfsFileDisableDirectRead (line 233) | void hdfsFileDisableDirectRead(hdfsFile file)
  function hdfsDisableDomainSocketSecurity (line 238) | int hdfsDisableDomainSocketSecurity(void)
  type hdfsJniEnv (line 261) | typedef struct
  function jthrowable (line 273) | static jthrowable constructNewObjectOfPath(JNIEnv *env, const char *path,
  function jthrowable (line 294) | static jthrowable hadoopConfGetStr(JNIEnv *env, jobject jConfiguration,
  function hdfsConfGetStr (line 317) | int hdfsConfGetStr(const char *key, char **val)
  function hdfsConfStrFree (line 349) | void hdfsConfStrFree(char *val)
  function jthrowable (line 354) | static jthrowable hadoopConfGetInt(JNIEnv *env, jobject jConfiguration,
  function hdfsConfGetInt (line 374) | int hdfsConfGetInt(const char *key, int32_t *val)
  type hdfsBuilderConfOpt (line 406) | struct hdfsBuilderConfOpt {
  type hdfsBuilder (line 412) | struct hdfsBuilder {
  type hdfsBuilder (line 421) | struct hdfsBuilder
  type hdfsBuilder (line 423) | struct hdfsBuilder
  type hdfsBuilder (line 423) | struct hdfsBuilder
  function hdfsBuilderConfSetStr (line 431) | int hdfsBuilderConfSetStr(struct hdfsBuilder *bld, const char *key,
  function hdfsFreeBuilder (line 447) | void hdfsFreeBuilder(struct hdfsBuilder *bld)
  function hdfsBuilderSetForceNewInstance (line 460) | void hdfsBuilderSetForceNewInstance(struct hdfsBuilder *bld)
  function hdfsBuilderSetNameNode (line 465) | void hdfsBuilderSetNameNode(struct hdfsBuilder *bld, const char *nn)
  function hdfsBuilderSetNameNodePort (line 470) | void hdfsBuilderSetNameNodePort(struct hdfsBuilder *bld, tPort port)
  function hdfsBuilderSetUserName (line 475) | void hdfsBuilderSetUserName(struct hdfsBuilder *bld, const char *userName)
  function hdfsBuilderSetKerbTicketCachePath (line 480) | void hdfsBuilderSetKerbTicketCachePath(struct hdfsBuilder *bld,
  function hdfsFS (line 486) | hdfsFS hdfsConnect(const char *host, tPort port)
  function hdfsFS (line 497) | hdfsFS hdfsConnectNewInstance(const char *host, tPort port)
  function hdfsFS (line 508) | hdfsFS hdfsConnectAsUser(const char *host, tPort port, const char *user)
  function hdfsFS (line 520) | hdfsFS hdfsConnectAsUserNewInstance(const char *host, tPort port,
  function calcEffectiveURI (line 549) | static int calcEffectiveURI(struct hdfsBuilder *bld, char ** uri)
  type hdfsBuilder (line 589) | struct hdfsBuilder
  function hdfsFS (line 599) | hdfsFS hdfsBuilderConnect(struct hdfsBuilder *bld)
  function hdfsDisconnect (line 774) | int hdfsDisconnect(hdfsFS fs)
  function jthrowable (line 825) | static jthrowable getDefaultBlockSize(JNIEnv *env, jobject jFS,
  function hdfsFile (line 839) | hdfsFile hdfsOpenFile(hdfsFS fs, const char *path, int flags,
  function hdfsTruncateFile (line 1029) | int hdfsTruncateFile(hdfsFS fs, const char* path, tOffset newlength)
  function hdfsUnbufferFile (line 1066) | int hdfsUnbufferFile(hdfsFile file)
  function hdfsCloseFile (line 1094) | int hdfsCloseFile(hdfsFS fs, hdfsFile file)
  function hdfsExists (line 1145) | int hdfsExists(hdfsFS fs, const char *path)
  function readPrepare (line 1186) | static int readPrepare(JNIEnv* env, hdfsFS fs, hdfsFile f,
  function tSize (line 1207) | tSize hdfsRead(hdfsFS fs, hdfsFile f, void* buffer, tSize length)
  function tSize (line 1286) | tSize readDirect(hdfsFS fs, hdfsFile f, void* buffer, tSize length)
  function tSize (line 1327) | tSize hdfsPread(hdfsFS fs, hdfsFile f, tOffset position,
  function tSize (line 1395) | tSize hdfsWrite(hdfsFS fs, hdfsFile f, const void* buffer, tSize length)
  function hdfsSeek (line 1466) | int hdfsSeek(hdfsFS fs, hdfsFile f, tOffset desiredPos)
  function tOffset (line 1501) | tOffset hdfsTell(hdfsFS fs, hdfsFile f)
  function hdfsFlush (line 1540) | int hdfsFlush(hdfsFS fs, hdfsFile f)
  function hdfsHFlush (line 1569) | int hdfsHFlush(hdfsFS fs, hdfsFile f)
  function hdfsHSync (line 1598) | int hdfsHSync(hdfsFS fs, hdfsFile f)
  function hdfsAvailable (line 1627) | int hdfsAvailable(hdfsFS fs, hdfsFile f)
  function hdfsCopyImpl (line 1661) | static int hdfsCopyImpl(hdfsFS srcFS, const char *src, hdfsFS dstFS,
  function hdfsCopy (line 1737) | int hdfsCopy(hdfsFS srcFS, const char *src, hdfsFS dstFS, const char *dst)
  function hdfsMove (line 1742) | int hdfsMove(hdfsFS srcFS, const char *src, hdfsFS dstFS, const char *dst)
  function hdfsDelete (line 1747) | int hdfsDelete(hdfsFS fs, const char *path, int recursive)
  function hdfsRename (line 1792) | int hdfsRename(hdfsFS fs, const char *oldPath, const char *newPath)
  function hdfsSetWorkingDirectory (line 1929) | int hdfsSetWorkingDirectory(hdfsFS fs, const char *path)
  function hdfsCreateDirectory (line 1970) | int hdfsCreateDirectory(hdfsFS fs, const char *path)
  function hdfsSetReplication (line 2021) | int hdfsSetReplication(hdfsFS fs, const char *path, int16_t replication)
  function hdfsChown (line 2067) | int hdfsChown(hdfsFS fs, const char *path, const char *owner, const char...
  function hdfsChmod (line 2136) | int hdfsChmod(hdfsFS fs, const char *path, short mode)
  function hdfsUtime (line 2196) | int hdfsUtime(hdfsFS fs, const char *path, tTime mtime, tTime atime)
  type hadoopRzOptions (line 2246) | struct hadoopRzOptions
  type hadoopRzOptions (line 2254) | struct hadoopRzOptions
  type hadoopRzOptions (line 2256) | struct hadoopRzOptions
  type hadoopRzOptions (line 2265) | struct hadoopRzOptions
  function hadoopRzOptionsClearCached (line 2273) | static void hadoopRzOptionsClearCached(JNIEnv *env,
  function hadoopRzOptionsSetSkipChecksum (line 2283) | int hadoopRzOptionsSetSkipChecksum(
  function hadoopRzOptionsSetByteBufferPool (line 2297) | int hadoopRzOptionsSetByteBufferPool(
  function hadoopRzOptionsFree (line 2331) | void hadoopRzOptionsFree(struct hadoopRzOptions *opts)
  type hadoopRzBuffer (line 2346) | struct hadoopRzBuffer
  function jthrowable (line 2354) | static jthrowable hadoopRzOptionsGetEnumSet(JNIEnv *env,
  function hadoopReadZeroExtractBuffer (line 2405) | static int hadoopReadZeroExtractBuffer(JNIEnv *env,
  function translateZCRException (line 2493) | static int translateZCRException(JNIEnv *env, jthrowable exc)
  type hadoopRzBuffer (line 2518) | struct hadoopRzBuffer
  type hadoopRzOptions (line 2519) | struct hadoopRzOptions
  type hadoopRzBuffer (line 2525) | struct hadoopRzBuffer
  type hadoopRzBuffer (line 2538) | struct hadoopRzBuffer
  function hadoopRzBufferLength (line 2591) | int32_t hadoopRzBufferLength(const struct hadoopRzBuffer *buffer)
  type hadoopRzBuffer (line 2596) | struct hadoopRzBuffer
  function hadoopRzBufferFree (line 2601) | void hadoopRzBufferFree(hdfsFile file, struct hadoopRzBuffer *buffer)
  function hdfsFreeHosts (line 2789) | void hdfsFreeHosts(char ***blockHosts)
  function tOffset (line 2802) | tOffset hdfsGetDefaultBlockSize(hdfsFS fs)
  function tOffset (line 2830) | tOffset hdfsGetDefaultBlockSizeAtPath(hdfsFS fs, const char *path)
  function tOffset (line 2864) | tOffset hdfsGetCapacity(hdfsFS fs)
  function tOffset (line 2904) | tOffset hdfsGetUsed(hdfsFS fs)
  function getExtendedFileInfoOffset (line 2961) | static size_t getExtendedFileInfoOffset(const char *str)
  type hdfsExtendedFileInfo (line 2967) | struct hdfsExtendedFileInfo
  type hdfsExtendedFileInfo (line 2970) | struct hdfsExtendedFileInfo
  function jthrowable (line 2974) | static jthrowable
  function jthrowable (line 3124) | static jthrowable
  function hdfsFileInfo (line 3167) | hdfsFileInfo* hdfsListDirectory(hdfsFS fs, const char *path, int *numEnt...
  function hdfsFileInfo (line 3263) | hdfsFileInfo *hdfsGetPathInfo(hdfsFS fs, const char *path)
  function hdfsFreeFileInfoEntry (line 3307) | static void hdfsFreeFileInfoEntry(hdfsFileInfo *hdfsFileInfo)
  function hdfsFreeFileInfo (line 3315) | void hdfsFreeFileInfo(hdfsFileInfo *hdfsFileInfo, int numEntries)
  function hdfsFileIsEncrypted (line 3327) | int hdfsFileIsEncrypted(hdfsFileInfo *fileInfo)

FILE: src/libhdfs/include/hdfs/hdfs.h
  type hdfsBuilder (line 74) | struct hdfsBuilder
  type tSize (line 75) | typedef int32_t   tSize;
  type time_t (line 76) | typedef time_t    tTime;
  type tOffset (line 77) | typedef int64_t   tOffset;
  type tPort (line 78) | typedef uint16_t  tPort;
  type tObjectKind (line 79) | typedef enum tObjectKind {
  type hdfs_internal (line 88) | struct hdfs_internal
  type hdfs_internal (line 89) | struct hdfs_internal
  type hdfsFile_internal (line 91) | struct hdfsFile_internal
  type hdfsFile_internal (line 92) | struct hdfsFile_internal
  type hadoopRzOptions (line 94) | struct hadoopRzOptions
  type hadoopRzBuffer (line 96) | struct hadoopRzBuffer
  type hdfsReadStatistics (line 116) | struct hdfsReadStatistics {
  type hdfsReadStatistics (line 138) | struct hdfsReadStatistics
  type hdfsReadStatistics (line 147) | struct hdfsReadStatistics
  type hdfsReadStatistics (line 169) | struct hdfsReadStatistics
  type hdfsBuilder (line 234) | struct hdfsBuilder
  type hdfsBuilder (line 251) | struct hdfsBuilder
  type hdfsBuilder (line 275) | struct hdfsBuilder
  type hdfsBuilder (line 284) | struct hdfsBuilder
  type hdfsBuilder (line 293) | struct hdfsBuilder
  type hdfsBuilder (line 304) | struct hdfsBuilder
  type hdfsBuilder (line 316) | struct hdfsBuilder
  type hdfsBuilder (line 330) | struct hdfsBuilder
  type hdfsFileInfo (line 654) | typedef struct  {
  type hadoopRzOptions (line 843) | struct hadoopRzOptions
  type hadoopRzOptions (line 861) | struct hadoopRzOptions
  type hadoopRzOptions (line 870) | struct hadoopRzOptions
  type hadoopRzOptions (line 897) | struct hadoopRzOptions
  type hadoopRzBuffer (line 906) | struct hadoopRzBuffer
  type hadoopRzBuffer (line 919) | struct hadoopRzBuffer
  type hadoopRzBuffer (line 929) | struct hadoopRzBuffer

FILE: src/libhdfs/jni_helper.c
  type htable (line 30) | struct htable
  function destroyLocalReference (line 57) | void destroyLocalReference(JNIEnv *env, jobject jObject)
  function jthrowable (line 63) | static jthrowable validateMethodType(JNIEnv *env, MethType methType)
  function jthrowable (line 72) | jthrowable newJavaStr(JNIEnv *env, const char *str, jstring *out)
  function jthrowable (line 92) | jthrowable newCStr(JNIEnv *env, jstring jstr, char **out)
  function jthrowable (line 109) | jthrowable invokeMethod(JNIEnv *env, jvalue *retval, MethType methType,
  function jthrowable (line 203) | jthrowable constructNewObjectOfClass(JNIEnv *env, jobject *out, const ch...
  function jthrowable (line 229) | jthrowable methodIdFromClass(const char *className, const char *methName,
  function jthrowable (line 258) | jthrowable globalClassReference(const char *className, JNIEnv *env, jcla...
  function jthrowable (line 306) | jthrowable classNameOfObject(jobject jobj, JNIEnv *env, char **name)
  function JNIEnv (line 369) | static JNIEnv* getGlobalJNIEnv(void)
  function JNIEnv (line 499) | JNIEnv* getJNIEnv(void)
  function javaObjectIsOfClass (line 526) | int javaObjectIsOfClass(JNIEnv *env, jobject obj, const char *name)
  function jthrowable (line 542) | jthrowable hadoopConfSetStr(JNIEnv *env, jobject jConfiguration,
  function jthrowable (line 566) | jthrowable fetchEnumInstance(JNIEnv *env, const char *className,

FILE: src/libhdfs/jni_helper.h
  type MethType (line 33) | typedef enum {

FILE: src/libhdfs/os/posix/mutexes.c
  function mutexLock (line 27) | int mutexLock(mutex *m) {
  function mutexUnlock (line 36) | int mutexUnlock(mutex *m) {

FILE: src/libhdfs/os/posix/platform.h
  type pthread_mutex_t (line 31) | typedef pthread_mutex_t mutex;
  type pthread_t (line 32) | typedef pthread_t threadId;

FILE: src/libhdfs/os/posix/thread.c
  function threadCreate (line 37) | int threadCreate(thread *t) {
  function threadJoin (line 46) | int threadJoin(const thread *t) {

FILE: src/libhdfs/os/posix/thread_local_storage.c
  function hdfsThreadDestructor (line 37) | static void hdfsThreadDestructor(void *v)
  function threadLocalStorageGet (line 53) | int threadLocalStorageGet(JNIEnv **env)
  function threadLocalStorageSet (line 70) | int threadLocalStorageSet(JNIEnv *env)

FILE: src/libhdfs/os/thread.h
  type thread (line 32) | typedef struct {

FILE: src/libhdfs/os/windows/mutexes.c
  function initializeMutexes (line 36) | static void __cdecl initializeMutexes(void) {
  function mutexLock (line 44) | int mutexLock(mutex *m) {
  function mutexUnlock (line 49) | int mutexUnlock(mutex *m) {

FILE: src/libhdfs/os/windows/platform.h
  type CRITICAL_SECTION (line 79) | typedef CRITICAL_SECTION mutex;
  type HANDLE (line 84) | typedef HANDLE threadId;

FILE: src/libhdfs/os/windows/thread.c
  function DWORD (line 31) | static DWORD WINAPI runThread(LPVOID toRun) {
  function threadCreate (line 37) | int threadCreate(thread *t) {
  function threadJoin (line 50) | int threadJoin(const thread *t) {

FILE: src/libhdfs/os/windows/thread_local_storage.c
  function detachCurrentThreadFromJvm (line 32) | static void detachCurrentThreadFromJvm()
  function tlsCallback (line 68) | static void NTAPI tlsCallback(PVOID h, DWORD reason, PVOID pv)
  function threadLocalStorageGet (line 125) | int threadLocalStorageGet(JNIEnv **env)
  function threadLocalStorageSet (line 161) | int threadLocalStorageSet(JNIEnv *env)

FILE: src/native_core_hdfs/hdfs_file.cc
  function PyObject (line 26) | PyObject* FileClass_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
  function FileClass_dealloc (line 52) | void FileClass_dealloc(FileInfo* self)
  function FileClass_init (line 59) | int FileClass_init(FileInfo *self, PyObject *args, PyObject *kwds)
  function FileClass_init_internal (line 85) | int FileClass_init_internal(FileInfo *self, hdfsFS fs, hdfsFile file)
  function PyObject (line 94) | PyObject* FileClass_close(FileInfo* self){
  function PyObject (line 105) | PyObject* FileClass_getclosed(FileInfo* self, void* closure) {
  function PyObject (line 110) | PyObject* FileClass_getbuff_size(FileInfo* self, void* closure) {
  function PyObject (line 115) | PyObject* FileClass_getname(FileInfo* self, void* closure) {
  function PyObject (line 121) | PyObject* FileClass_getmode(FileInfo* self, void* closure) {
  function PyObject (line 127) | PyObject* FileClass_readable(FileInfo* self) {
  function PyObject (line 132) | PyObject* FileClass_writable(FileInfo* self) {
  function PyObject (line 137) | PyObject* FileClass_seekable(FileInfo* self) {
  function PyObject (line 142) | PyObject* FileClass_available(FileInfo *self){
  function _ensure_open_for_reading (line 150) | static int _ensure_open_for_reading(FileInfo* self) {
  function Py_ssize_t (line 159) | static Py_ssize_t _read_into_pybuf(FileInfo *self, char* buf, Py_ssize_t...
  function PyObject (line 179) | static PyObject* _read_new_pybuf(FileInfo* self, Py_ssize_t nbytes) {
  function Py_ssize_t (line 217) | static Py_ssize_t _pread_into_pybuf(FileInfo *self, char* buffer, Py_ssi...
  function PyObject (line 246) | static PyObject* _pread_new_pybuf(FileInfo* self, Py_ssize_t pos, Py_ssi...
  function PyObject (line 276) | PyObject* FileClass_read(FileInfo *self, PyObject *args, PyObject *kwds){
  function PyObject (line 299) | PyObject* FileClass_read_chunk(FileInfo *self, PyObject *args, PyObject ...
  function PyObject (line 319) | PyObject* FileClass_pread(FileInfo *self, PyObject *args, PyObject *kwds){
  function PyObject (line 346) | PyObject* FileClass_pread_chunk(FileInfo *self, PyObject *args, PyObject...
  function PyObject (line 375) | PyObject* FileClass_seek(FileInfo *self, PyObject *args, PyObject *kwds) {
  function PyObject (line 416) | PyObject* FileClass_tell(FileInfo *self, PyObject *args, PyObject *kwds){
  function PyObject (line 429) | PyObject* FileClass_write(FileInfo* self, PyObject *args, PyObject *kwds) {
  function PyObject (line 458) | PyObject* FileClass_flush(FileInfo *self){

FILE: src/native_core_hdfs/hdfs_file.h
  type FileInfo (line 38) | typedef struct {

FILE: src/native_core_hdfs/hdfs_fs.cc
  function PyObject (line 33) | PyObject* FsClass_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
  function FsClass_dealloc (line 50) | void FsClass_dealloc(FsInfo* self)
  function FsClass_init (line 56) | int FsClass_init(FsInfo *self, PyObject *args, PyObject *kwds)
  function PyObject (line 95) | PyObject* FsClass_close(FsInfo* self)
  function PyObject (line 102) | PyObject* FsClass_get_working_directory(FsInfo* self) {
  function PyObject (line 123) | PyObject* FsClass_get_path_info(FsInfo* self, PyObject *args, PyObject *...
  function PyObject (line 167) | PyObject* FsClass_get_hosts(FsInfo* self, PyObject *args, PyObject *kwds) {
  function PyObject (line 228) | PyObject* FsClass_get_default_block_size(FsInfo* self) {
  function PyObject (line 233) | PyObject* FsClass_get_used(FsInfo* self) {
  function PyObject (line 238) | PyObject* FsClass_set_replication(FsInfo* self, PyObject* args, PyObject...
  function PyObject (line 264) | PyObject* FsClass_set_working_directory(FsInfo* self, PyObject* args, Py...
  function PyObject (line 289) | PyObject* FsClass_open_file(FsInfo* self, PyObject *args, PyObject *kwds)
  function PyObject (line 377) | PyObject *FsClass_get_capacity(FsInfo *self) {
  function PyObject (line 403) | PyObject* FsClass_copy(FsInfo* self, PyObject *args, PyObject *kwds)
  function PyObject (line 433) | PyObject *FsClass_exists(FsInfo *self, PyObject *args, PyObject *kwds) {
  function PyObject (line 464) | PyObject *FsClass_create_directory(FsInfo *self, PyObject *args, PyObjec...
  function setPathInfo (line 496) | static int setPathInfo(PyObject* dict, hdfsFileInfo* fileInfo) {
  function PyObject (line 549) | PyObject *FsClass_list_directory(FsInfo *self, PyObject *args, PyObject ...
  function PyObject (line 628) | PyObject *FsClass_move(FsInfo *self, PyObject *args, PyObject *kwds) {
  function PyObject (line 659) | PyObject *FsClass_rename(FsInfo *self, PyObject *args, PyObject *kwds) {
  function PyObject (line 686) | PyObject *FsClass_delete(FsInfo *self, PyObject *args, PyObject *kwds) {
  function PyObject (line 714) | PyObject *FsClass_chmod(FsInfo *self, PyObject *args, PyObject *kwds) {
  function PyObject (line 754) | PyObject *FsClass_chown(FsInfo *self, PyObject *args, PyObject *kwds) {
  function PyObject (line 796) | PyObject *FsClass_utime(FsInfo *self, PyObject *args, PyObject *kwds) {

FILE: src/native_core_hdfs/hdfs_fs.h
  type FsInfo (line 42) | typedef struct {

FILE: src/native_core_hdfs/hdfs_module.cc
  type PyModuleDef (line 216) | struct PyModuleDef
  function PyMODINIT_FUNC (line 232) | PyMODINIT_FUNC
  function PyMODINIT_FUNC (line 255) | PyMODINIT_FUNC

FILE: src/sercore/HadoopUtils/SerialUtils.cc
  type HadoopUtils (line 28) | namespace HadoopUtils {
    function serializeInt (line 177) | void serializeInt(int32_t t, OutStream& stream) {
    function serializeLong (line 181) | void serializeLong(int64_t t, OutStream& stream)
    function deserializeInt (line 212) | int32_t deserializeInt(InStream& stream) {
    function deserializeLong (line 216) | int64_t deserializeLong(InStream& stream)
    function serializeFloat (line 245) | void serializeFloat(float t, OutStream& stream)
    function deserializeFloat (line 254) | float deserializeFloat(InStream& stream)
    function deserializeFloat (line 261) | void deserializeFloat(float& t, InStream& stream)
    function serializeString (line 270) | void serializeString(const std::string& t, OutStream& stream)
    function deserializeString (line 278) | void deserializeString(std::string& t, InStream& stream)

FILE: src/sercore/HadoopUtils/SerialUtils.hh
  type HadoopUtils (line 24) | namespace HadoopUtils {
    class Error (line 29) | class Error {
    class InStream (line 68) | class InStream {
    class OutStream (line 83) | class OutStream {
    class FileInStream (line 102) | class FileInStream : public InStream {
    class FileOutStream (line 125) | class FileOutStream: public OutStream {
    class StringInStream (line 151) | class StringInStream: public InStream {

FILE: src/sercore/hu_extras.cpp
  function deserializeLongWritable (line 24) | int64_t deserializeLongWritable(HadoopUtils::InStream& stream) {

FILE: src/sercore/sercore.cpp
  function PyObject (line 36) | static PyObject *
  type PyModuleDef (line 97) | struct PyModuleDef
  function initsercore (line 115) | initsercore(void) {

FILE: src/sercore/streams.cpp
  function FILE (line 52) | FILE *
  function FileInStream_init (line 77) | static int
  function PyObject (line 108) | static PyObject *
  function PyObject (line 129) | static PyObject *
  function PyObject (line 137) | static PyObject *
  function PyObject (line 143) | static PyObject *
  function PyObject (line 169) | static PyObject *
  function PyObject (line 187) | static PyObject *
  function PyObject (line 205) | static PyObject *
  function _FileInStream_read_cppstring (line 223) | std::string
  function PyObject (line 240) | static PyObject *
  function PyObject (line 253) | static PyObject *
  function PyObject (line 266) | static PyObject *
  function PyObject (line 310) | static PyObject *
  function PyObject (line 340) | static PyObject *
  function FileOutStream_init (line 427) | static int
  function PyObject (line 458) | static PyObject *
  function PyObject (line 479) | static PyObject *
  function PyObject (line 487) | static PyObject *
  function PyObject (line 493) | static PyObject *
  function PyObject (line 519) | static PyObject *
  function PyObject (line 540) | static PyObject *
  function PyObject (line 561) | static PyObject *
  function PyObject (line 582) | static PyObject*
  function PyObject (line 597) | static PyObject *
  function PyObject (line 628) | static PyObject *
  function PyObject (line 656) | static PyObject *
  function PyObject (line 710) | static PyObject *
  function PyObject (line 769) | static PyObject *
  function PyObject (line 788) | static PyObject *

FILE: src/sercore/streams.h
  type FileInStreamObj (line 27) | typedef struct {
  type FileOutStreamObj (line 34) | typedef struct {

FILE: test/all_tests.py
  function suite (line 32) | def suite():

FILE: test/app/all_tests.py
  function suite (line 28) | def suite(path=None):

FILE: test/app/test_submit.py
  function nop (line 31) | def nop(x=None):
  class Args (line 35) | class Args(object):
    method __init__ (line 36) | def __init__(self, **kwargs):
    method __getattr__ (line 40) | def __getattr__(self, _):
  class TestAppSubmit (line 47) | class TestAppSubmit(unittest.TestCase):
    method setUp (line 49) | def setUp(self):
    method _gen_default_args (line 53) | def _gen_default_args():
    method test_help (line 67) | def test_help(self):
    method _check_args (line 90) | def _check_args(self, args, args_kv):
    method test_conf_file (line 102) | def test_conf_file(self):
    method test_empty_param (line 131) | def test_empty_param(self):
    method test_generate_pipes_code_env (line 141) | def test_generate_pipes_code_env(self):
    method test_generate_pipes_code_no_override_ld_path (line 157) | def test_generate_pipes_code_no_override_ld_path(self):
    method test_generate_pipes_code_no_override_path (line 171) | def test_generate_pipes_code_no_override_path(self):
    method test_generate_pipes_code_no_override_pythonpath (line 180) | def test_generate_pipes_code_no_override_pythonpath(self):
    method test_generate_pipes_code_with_set_env (line 189) | def test_generate_pipes_code_with_set_env(self):
    method test_generate_code_no_env_override (line 204) | def test_generate_code_no_env_override(self):
    method test_generate_code_no_env_override_with_set_env (line 216) | def test_generate_code_no_env_override_with_set_env(self):
    method test_env_arg_to_dict (line 230) | def test_env_arg_to_dict(self):
    method test_bad_upload_files (line 237) | def test_bad_upload_files(self):
    method test_pretend (line 242) | def test_pretend(self):
  function suite (line 255) | def suite():

FILE: test/avro/all_tests.py
  function suite (line 28) | def suite(path=None):

FILE: test/avro/common.py
  class AvroSerializer (line 24) | class AvroSerializer(object):
    method __init__ (line 26) | def __init__(self, schema):
    method serialize (line 30) | def serialize(self, record):
  function avro_user_record (line 37) | def avro_user_record(i):

FILE: test/avro/test_io.py
  class TestAvroIO (line 40) | class TestAvroIO(WDTestCase):
    method setUp (line 42) | def setUp(self):
    method write_avro_file (line 47) | def write_avro_file(self, rec_creator, n_samples, sync_interval):
    method test_seekable (line 56) | def test_seekable(self):
    method test_avro_reader (line 93) | def test_avro_reader(self):
    method test_avro_writer (line 121) | def test_avro_writer(self):
  function suite (line 146) | def suite():

FILE: test/common/all_tests.py
  function suite (line 32) | def suite(path=None):
  function main (line 39) | def main():

FILE: test/common/test_hadoop_utils.py
  class TestHadoopUtils (line 31) | class TestHadoopUtils(unittest.TestCase):
    method setUp (line 33) | def setUp(self):
    method tearDown (line 41) | def tearDown(self):
    method test_get_hadoop_params (line 46) | def test_get_hadoop_params(self):
    method __check_params (line 60) | def __check_params(self, xml_content=None, expected=None):
  function suite (line 73) | def suite():

FILE: test/common/test_hadut.py
  function pair_set (line 31) | def pair_set(seq):
  class TestHadut (line 35) | class TestHadut(unittest.TestCase):
    method assertEqualPairSet (line 42) | def assertEqualPairSet(self, seq1, seq2):
    method test_pop_generic_args (line 45) | def test_pop_generic_args(self):
    method test_merge_csv_args (line 60) | def test_merge_csv_args(self):
    method test_cmd (line 78) | def test_cmd(self):
    method test_run_class (line 82) | def test_run_class(self):
  function suite (line 89) | def suite():

FILE: test/common/test_pydoop.py
  class TestPydoop (line 32) | class TestPydoop(unittest.TestCase):
    method setUp (line 34) | def setUp(self):
    method tearDown (line 41) | def tearDown(self):
    method test_home (line 50) | def test_home(self):
    method test_conf (line 59) | def test_conf(self):
    method test_pydoop_jar_path (line 67) | def test_pydoop_jar_path(self):
  function suite (line 76) | def suite():

FILE: test/common/test_test_support.py
  class TestTestSupport (line 40) | class TestTestSupport(unittest.TestCase):
    method test_inject_code (line 42) | def test_inject_code(self):
    method test_set_python_cmd (line 51) | def test_set_python_cmd(self):
  function suite (line 57) | def suite():

FILE: test/hdfs/all_tests.py
  function suite (line 32) | def suite(path=None):

FILE: test/hdfs/common_hdfs_tests.py
  class TestCommon (line 33) | class TestCommon(unittest.TestCase):
    method __init__ (line 35) | def __init__(self, target, hdfs_host='', hdfs_port=0):
    method setUp (line 40) | def setUp(self):
    method tearDown (line 44) | def tearDown(self):
    method _make_random_path (line 48) | def _make_random_path(self, where=None, add_uni=True):
    method _make_random_dir (line 55) | def _make_random_dir(self, where=None, add_uni=True):
    method _make_random_file (line 62) | def _make_random_file(self, where=None, content=None, **kwargs):
    method failUnlessRaisesExternal (line 77) | def failUnlessRaisesExternal(self, excClass, callableObj, *args, **kwa...
    method assertEqualPathInfo (line 84) | def assertEqualPathInfo(self, info1, info2, tolerance=10):
    method open_close (line 101) | def open_close(self):
    method delete (line 112) | def delete(self):
    method copy (line 126) | def copy(self):
    method move (line 141) | def move(self):
    method chmod (line 151) | def chmod(self):
    method __set_and_check_perm (line 162) | def __set_and_check_perm(self, path, new_mode, expected_mode):
    method chmod_w_string (line 167) | def chmod_w_string(self):
    method file_attrs (line 192) | def file_attrs(self):
    method flush (line 212) | def flush(self):
    method available (line 218) | def available(self):
    method get_path_info (line 224) | def get_path_info(self):
    method read (line 239) | def read(self):
    method __read_chunk (line 254) | def __read_chunk(self, chunk_factory):
    method read_chunk (line 266) | def read_chunk(self):
    method write (line 272) | def write(self):
    method append (line 290) | def append(self):
    method tell (line 306) | def tell(self):
    method pread (line 313) | def pread(self):
    method pread_chunk (line 330) | def pread_chunk(self):
    method copy_on_self (line 341) | def copy_on_self(self):
    method rename (line 349) | def rename(self):
    method change_dir (line 358) | def change_dir(self):
    method list_directory (line 367) | def list_directory(self):
    method __check_readline (line 383) | def __check_readline(self, get_lines):
    method readline (line 400) | def readline(self):
    method readline_big (line 411) | def readline_big(self):
    method readline_and_read (line 421) | def readline_and_read(self):
    method iter_lines (line 431) | def iter_lines(self):
    method seek (line 448) | def seek(self):
    method block_boundary (line 471) | def block_boundary(self):
    method walk (line 497) | def walk(self):
    method exists (line 538) | def exists(self):
    method text_io (line 547) | def text_io(self):
    method __check_path_info (line 568) | def __check_path_info(self, info, **expected_values):
  function common_tests (line 578) | def common_tests():

FILE: test/hdfs/test_common.py
  class TestMode (line 24) | class TestMode(unittest.TestCase):
    method runTest (line 26) | def runTest(self):
  function suite (line 40) | def suite():

FILE: test/hdfs/test_core.py
  class TestCore (line 26) | class TestCore(unittest.TestCase):
    method test_default (line 28) | def test_default(self):
  function suite (line 43) | def suite():

FILE: test/hdfs/test_hdfs.py
  class TestHDFS (line 33) | class TestHDFS(unittest.TestCase):
    method setUp (line 35) | def setUp(self):
    method tearDown (line 55) | def tearDown(self):
    method open (line 63) | def open(self):
    method dump (line 72) | def dump(self):
    method __ls (line 80) | def __ls(self, ls_func, path_transform):
    method lsl (line 98) | def lsl(self):
    method ls (line 101) | def ls(self):
    method mkdir (line 104) | def mkdir(self):
    method load (line 113) | def load(self):
    method __make_tree (line 119) | def __make_tree(self, wd, root="d1", create=True):
    method __cp_file (line 139) | def __cp_file(self, wd):
    method __cp_dir (line 153) | def __cp_dir(self, wd):
    method __cp_recursive (line 164) | def __cp_recursive(self, wd):
    method cp (line 187) | def cp(self):
    method put (line 193) | def put(self):
    method get (line 203) | def get(self):
    method rm (line 212) | def rm(self):
    method chmod (line 218) | def chmod(self):
    method move (line 224) | def move(self):
    method chown (line 234) | def chown(self):
    method rename (line 249) | def rename(self):
    method renames (line 261) | def renames(self):
    method capacity (line 270) | def capacity(self):
    method get_hosts (line 279) | def get_hosts(self):
    method thread_allow (line 292) | def thread_allow(self):
  function suite (line 371) | def suite():

FILE: test/hdfs/test_hdfs_fs.py
  function get_explicit_hp (line 34) | def get_explicit_hp():
  class TestConnection (line 41) | class TestConnection(unittest.TestCase):
    method setUp (line 43) | def setUp(self):
    method connect (line 57) | def connect(self):
    method cache (line 64) | def cache(self):
  class TestHDFS (line 78) | class TestHDFS(TestCommon):
    method __init__ (line 80) | def __init__(self, target):
    method capacity (line 83) | def capacity(self):
    method default_block_size (line 87) | def default_block_size(self):
    method used (line 91) | def used(self):
    method chown (line 95) | def chown(self):
    method utime (line 111) | def utime(self):
    method block_size (line 132) | def block_size(self):
    method replication (line 138) | def replication(self):
    method set_replication (line 143) | def set_replication(self):
    method readline_block_boundary (line 151) | def readline_block_boundary(self):
    method get_hosts (line 186) | def get_hosts(self):
  function suite (line 199) | def suite():

FILE: test/hdfs/test_local_fs.py
  class TestConnection (line 28) | class TestConnection(unittest.TestCase):
    method runTest (line 30) | def runTest(self):
  class TestLocalFS (line 42) | class TestLocalFS(TestCommon):
    method __init__ (line 44) | def __init__(self, target):
  function suite (line 48) | def suite():

FILE: test/hdfs/test_path.py
  function uni_last (line 30) | def uni_last(tup):
  class TestSplit (line 34) | class TestSplit(unittest.TestCase):
    method good (line 36) | def good(self):
    method good_with_user (line 67) | def good_with_user(self):
    method bad (line 84) | def bad(self):
    method splitext (line 100) | def splitext(self):
  class TestUnparse (line 108) | class TestUnparse(unittest.TestCase):
    method good (line 110) | def good(self):
    method bad (line 121) | def bad(self):
  class TestJoin (line 125) | class TestJoin(unittest.TestCase):
    method __check_join (line 127) | def __check_join(self, cases):
    method simple (line 131) | def simple(self):
    method slashes (line 137) | def slashes(self):
    method absolute (line 143) | def absolute(self):
    method full (line 151) | def full(self):
    method unicode_ (line 158) | def unicode_(self):
  class TestAbspath (line 164) | class TestAbspath(unittest.TestCase):
    method setUp (line 166) | def setUp(self):
    method without_user (line 175) | def without_user(self):
    method with_user (line 186) | def with_user(self):
    method forced_local (line 195) | def forced_local(self):
    method already_absolute (line 200) | def already_absolute(self):
  class TestSplitBasenameDirname (line 210) | class TestSplitBasenameDirname(unittest.TestCase):
    method runTest (line 212) | def runTest(self):
  class TestExists (line 230) | class TestExists(unittest.TestCase):
    method good (line 232) | def good(self):
  class TestKind (line 241) | class TestKind(unittest.TestCase):
    method setUp (line 243) | def setUp(self):
    method test_kind (line 247) | def test_kind(self):
    method test_isfile (line 262) | def test_isfile(self):
    method test_isdir (line 277) | def test_isdir(self):
  class TestExpand (line 293) | class TestExpand(unittest.TestCase):
    method expanduser (line 295) | def expanduser(self):
    method expanduser_no_expansion (line 307) | def expanduser_no_expansion(self):
    method expandvars (line 313) | def expandvars(self):
  class TestStat (line 324) | class TestStat(unittest.TestCase):
    method stat (line 336) | def stat(self):
    method stat_on_local (line 356) | def stat_on_local(self):
    method stat_on_dir (line 386) | def stat_on_dir(self):
    method __check_extra_args (line 402) | def __check_extra_args(self, stat_res, path_info):
    method __check_wrapper_funcs (line 408) | def __check_wrapper_funcs(self, path):
  class TestIsSomething (line 414) | class TestIsSomething(unittest.TestCase):
    method full_and_abs (line 416) | def full_and_abs(self):
    method islink (line 425) | def islink(self):
    method ismount (line 434) | def ismount(self):
  class TestNorm (line 438) | class TestNorm(unittest.TestCase):
    method normpath (line 440) | def normpath(self):
  class TestReal (line 448) | class TestReal(unittest.TestCase):
    method realpath (line 450) | def realpath(self):
  class TestSame (line 460) | class TestSame(unittest.TestCase):
    method samefile_link (line 462) | def samefile_link(self):
    method samefile_rel (line 470) | def samefile_rel(self):
    method samefile_norm (line 476) | def samefile_norm(self):
    method samefile_user (line 480) | def samefile_user(self):
  class TestAccess (line 485) | class TestAccess(unittest.TestCase):
    method setUp (line 487) | def setUp(self):
    method tearDown (line 491) | def tearDown(self):
    method __test (line 495) | def __test(self, offset, user=None):
    method test_owner (line 501) | def test_owner(self):
    method test_other (line 504) | def test_other(self):
  class TestUtime (line 508) | class TestUtime(unittest.TestCase):
    method runTest (line 510) | def runTest(self):
  class TestCallFromHdfs (line 523) | class TestCallFromHdfs(unittest.TestCase):
    method setUp (line 525) | def setUp(self):
    method tearDown (line 529) | def tearDown(self):
    method test_stat (line 532) | def test_stat(self):
    method test_access (line 539) | def test_access(self):
    method test_utime (line 544) | def test_utime(self):
  function suite (line 551) | def suite():

FILE: test/hdfs/try_hdfs.py
  function dump_status (line 36) | def dump_status(fs):
  function main (line 43) | def main(argv=sys.argv[1:]):

FILE: test/mapreduce/all_tests.py
  function suite (line 29) | def suite(path=None):

FILE: test/mapreduce/it/crs4/pydoop/mapreduce/pipes/OpaqueRoundtrip.java
  class OpaqueRoundtrip (line 45) | public class OpaqueRoundtrip {
    method main (line 47) | public static void main(String[] args)

FILE: test/mapreduce/test_connections.py
  class Mapper (line 33) | class Mapper(api.Mapper):
    method map (line 35) | def map(self, context):
  class Reducer (line 39) | class Reducer(api.Reducer):
    method reduce (line 41) | def reduce(self, context):
  class UplinkDumpReader (line 46) | class UplinkDumpReader(object):
    method __init__ (line 48) | def __init__(self, stream):
    method close (line 51) | def close(self):
    method __next__ (line 54) | def __next__(self):
    method __iter__ (line 75) | def __iter__(self):
    method next (line 79) | def next(self):
  class TestFileConnection (line 83) | class TestFileConnection(WDTestCase):
    method test_map (line 85) | def test_map(self):
    method test_reduce (line 89) | def test_reduce(self):
    method __run_test (line 93) | def __run_test(self, name, factory, **kwargs):
  function suite (line 107) | def suite():

FILE: test/mapreduce/test_opaque.py
  class TestOpaqueSplit (line 37) | class TestOpaqueSplit(unittest.TestCase):
    method setUp (line 39) | def setUp(self):
    method tearDown (line 43) | def tearDown(self):
    method _make_random_path (line 47) | def _make_random_path(self, where=None):
    method _generate_opaque_splits (line 50) | def _generate_opaque_splits(self, n):
    method _test_opaque (line 53) | def _test_opaque(self, o, no):
    method _test_opaques (line 56) | def _test_opaques(self, opaques, nopaques):
    method _run_java (line 61) | def _run_java(self, in_uri, out_uri, wd):
    method _do_java_roundtrip (line 72) | def _do_java_roundtrip(self, splits, wd='/tmp'):
    method test_opaque (line 82) | def test_opaque(self):
    method test_write_read_opaque_splits (line 94) | def test_write_read_opaque_splits(self):
    method test_opaque_java_round_trip (line 105) | def test_opaque_java_round_trip(self):
  function suite (line 115) | def suite():

FILE: test/sercore/all_tests.py
  function suite (line 29) | def suite(path=None):

FILE: test/sercore/test_deser.py
  class TestFileSplit (line 28) | class TestFileSplit(unittest.TestCase):
    method setUp (line 30) | def setUp(self):
    method test_standard (line 43) | def test_standard(self):
    method test_errors (line 50) | def test_errors(self):
  function suite (line 60) | def suite():

FILE: test/sercore/test_streams.py
  class TestFileInStream (line 38) | class TestFileInStream(unittest.TestCase):
    method setUp (line 40) | def setUp(self):
    method test_from_path (line 44) | def test_from_path(self):
    method test_from_file (line 48) | def test_from_file(self):
    method test_errors (line 53) | def test_errors(self):
    method __check_stream (line 61) | def __check_stream(self, s):
  class TestFileOutStream (line 67) | class TestFileOutStream(unittest.TestCase):
    method setUp (line 69) | def setUp(self):
    method tearDown (line 74) | def tearDown(self):
    method test_from_path (line 77) | def test_from_path(self):
    method test_from_file (line 82) | def test_from_file(self):
    method test_errors (line 88) | def test_errors(self):
    method __fill_stream (line 92) | def __fill_stream(self, s):
    method __check_stream (line 98) | def __check_stream(self):
  class TestSerDe (line 103) | class TestSerDe(unittest.TestCase):
    method setUp (line 112) | def setUp(self):
    method tearDown (line 116) | def tearDown(self):
    method test_vint (line 119) | def test_vint(self):
    method test_vlong (line 125) | def test_vlong(self):
    method test_float (line 131) | def test_float(self):
    method test_string_as_string (line 137) | def test_string_as_string(self):
    method test_string_as_bytes (line 143) | def test_string_as_bytes(self):
    method test_bytes_as_string (line 149) | def test_bytes_as_string(self):
    method test_bytes_as_bytes (line 155) | def test_bytes_as_bytes(self):
    method test_output (line 161) | def test_output(self):
    method test_multi_no_tuple (line 178) | def test_multi_no_tuple(self):
    method test_multi_read_tuple (line 182) | def test_multi_read_tuple(self):
    method test_multi_write_tuple (line 186) | def test_multi_write_tuple(self):
    method test_multi_rw_tuple (line 190) | def test_multi_rw_tuple(self):
    method __fill_stream_multi (line 194) | def __fill_stream_multi(self):
    method __fill_stream_tuple (line 202) | def __fill_stream_tuple(self):
    method __check_stream_multi (line 206) | def __check_stream_multi(self):
    method __check_stream_tuple (line 214) | def __check_stream_tuple(self):
    method test_errors (line 224) | def test_errors(self):
    method test_string_keep_zeros (line 246) | def test_string_keep_zeros(self):
    method test_string_allow_bytes (line 254) | def test_string_allow_bytes(self):
  class TestCheckClosed (line 261) | class TestCheckClosed(unittest.TestCase):
    method test_instream (line 263) | def test_instream(self):
    method test_outstream (line 277) | def test_outstream(self):
    method test_double_close (line 295) | def test_double_close(self):
    method __check (line 313) | def __check(self, ops):
  class TestHadoopTypes (line 318) | class TestHadoopTypes(unittest.TestCase):
    method setUp (line 320) | def setUp(self):
    method test_long_writable (line 324) | def test_long_writable(self):
  function suite (line 352) | def suite():