Pipes.hh
上传用户:quxuerui
上传日期:2018-01-08
资源大小:41811k
文件大小:6k
源码类别:

网格计算

开发平台:

Java

  1. /**
  2.  * Licensed to the Apache Software Foundation (ASF) under one
  3.  * or more contributor license agreements.  See the NOTICE file
  4.  * distributed with this work for additional information
  5.  * regarding copyright ownership.  The ASF licenses this file
  6.  * to you under the Apache License, Version 2.0 (the
  7.  * "License"); you may not use this file except in compliance
  8.  * with the License.  You may obtain a copy of the License at
  9.  *
  10.  *     http://www.apache.org/licenses/LICENSE-2.0
  11.  *
  12.  * Unless required by applicable law or agreed to in writing, software
  13.  * distributed under the License is distributed on an "AS IS" BASIS,
  14.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15.  * See the License for the specific language governing permissions and
  16.  * limitations under the License.
  17.  */
  18. #ifndef HADOOP_PIPES_HH
  19. #define HADOOP_PIPES_HH
  20. #ifdef SWIG
  21. %module (directors="1") HadoopPipes
  22. %include "std_string.i"
  23. %feature("director") Mapper;
  24. %feature("director") Reducer;
  25. %feature("director") Partitioner;
  26. %feature("director") RecordReader;
  27. %feature("director") RecordWriter;
  28. %feature("director") Factory;
  29. #else
  30. #include <string>
  31. #endif
  32. namespace HadoopPipes {
  33. /**
  34.  * This interface defines the interface between application code and the 
  35.  * foreign code interface to Hadoop Map/Reduce.
  36.  */
  37. /**
  38.  * A JobConf defines the properties for a job.
  39.  */
  40. class JobConf {
  41. public:
  42.   virtual bool hasKey(const std::string& key) const = 0;
  43.   virtual const std::string& get(const std::string& key) const = 0;
  44.   virtual int getInt(const std::string& key) const = 0;
  45.   virtual float getFloat(const std::string& key) const = 0;
  46.   virtual bool getBoolean(const std::string&key) const = 0;
  47.   virtual ~JobConf() {}
  48. };
  49. /**
  50.  * Task context provides the information about the task and job.
  51.  */
  52. class TaskContext {
  53. public:
  54.   /**
  55.    * Counter to keep track of a property and its value.
  56.    */
  57.   class Counter {
  58.   private:
  59.     int id;
  60.   public:
  61.     Counter(int counterId) : id(counterId) {}
  62.     Counter(const Counter& counter) : id(counter.id) {}
  63.     int getId() const { return id; }
  64.   };
  65.   
  66.   /**
  67.    * Get the JobConf for the current task.
  68.    */
  69.   virtual const JobConf* getJobConf() = 0;
  70.   /**
  71.    * Get the current key. 
  72.    * @return the current key
  73.    */
  74.   virtual const std::string& getInputKey() = 0;
  75.   /**
  76.    * Get the current value. 
  77.    * @return the current value
  78.    */
  79.   virtual const std::string& getInputValue() = 0;
  80.   /**
  81.    * Generate an output record
  82.    */
  83.   virtual void emit(const std::string& key, const std::string& value) = 0;
  84.   /**
  85.    * Mark your task as having made progress without changing the status 
  86.    * message.
  87.    */
  88.   virtual void progress() = 0;
  89.   /**
  90.    * Set the status message and call progress.
  91.    */
  92.   virtual void setStatus(const std::string& status) = 0;
  93.   /**
  94.    * Register a counter with the given group and name.
  95.    */
  96.   virtual Counter* 
  97.     getCounter(const std::string& group, const std::string& name) = 0;
  98.   /**
  99.    * Increment the value of the counter with the given amount.
  100.    */
  101.   virtual void incrementCounter(const Counter* counter, uint64_t amount) = 0;
  102.   
  103.   virtual ~TaskContext() {}
  104. };
  105. class MapContext: public TaskContext {
  106. public:
  107.   /**
  108.    * Access the InputSplit of the mapper.
  109.    */
  110.   virtual const std::string& getInputSplit() = 0;
  111.   /**
  112.    * Get the name of the key class of the input to this task.
  113.    */
  114.   virtual const std::string& getInputKeyClass() = 0;
  115.   /**
  116.    * Get the name of the value class of the input to this task.
  117.    */
  118.   virtual const std::string& getInputValueClass() = 0;
  119. };
  120. class ReduceContext: public TaskContext {
  121. public:
  122.   /**
  123.    * Advance to the next value.
  124.    */
  125.   virtual bool nextValue() = 0;
  126. };
  127. class Closable {
  128. public:
  129.   virtual void close() {}
  130.   virtual ~Closable() {}
  131. };
  132. /**
  133.  * The application's mapper class to do map.
  134.  */
  135. class Mapper: public Closable {
  136. public:
  137.   virtual void map(MapContext& context) = 0;
  138. };
  139. /**
  140.  * The application's reducer class to do reduce.
  141.  */
  142. class Reducer: public Closable {
  143. public:
  144.   virtual void reduce(ReduceContext& context) = 0;
  145. };
  146. /**
  147.  * User code to decide where each key should be sent.
  148.  */
  149. class Partitioner {
  150. public:
  151.   virtual int partition(const std::string& key, int numOfReduces) = 0;
  152.   virtual ~Partitioner() {}
  153. };
  154. /**
  155.  * For applications that want to read the input directly for the map function
  156.  * they can define RecordReaders in C++.
  157.  */
  158. class RecordReader: public Closable {
  159. public:
  160.   virtual bool next(std::string& key, std::string& value) = 0;
  161.   /**
  162.    * The progress of the record reader through the split as a value between
  163.    * 0.0 and 1.0.
  164.    */
  165.   virtual float getProgress() = 0;
  166. };
  167. /**
  168.  * An object to write key/value pairs as they are emited from the reduce.
  169.  */
  170. class RecordWriter: public Closable {
  171. public:
  172.   virtual void emit(const std::string& key,
  173.                     const std::string& value) = 0;
  174. };
  175. /**
  176.  * A factory to create the necessary application objects.
  177.  */
  178. class Factory {
  179. public:
  180.   virtual Mapper* createMapper(MapContext& context) const = 0;
  181.   virtual Reducer* createReducer(ReduceContext& context) const = 0;
  182.   /**
  183.    * Create a combiner, if this application has one.
  184.    * @return the new combiner or NULL, if one is not needed
  185.    */
  186.   virtual Reducer* createCombiner(MapContext& context) const {
  187.     return NULL; 
  188.   }
  189.   /**
  190.    * Create an application partitioner object.
  191.    * @return the new partitioner or NULL, if the default partitioner should be 
  192.    *     used.
  193.    */
  194.   virtual Partitioner* createPartitioner(MapContext& context) const {
  195.     return NULL;
  196.   }
  197.   /**
  198.    * Create an application record reader.
  199.    * @return the new RecordReader or NULL, if the Java RecordReader should be
  200.    *    used.
  201.    */
  202.   virtual RecordReader* createRecordReader(MapContext& context) const {
  203.     return NULL; 
  204.   }
  205.   /**
  206.    * Create an application record writer.
  207.    * @return the new RecordWriter or NULL, if the Java RecordWriter should be
  208.    *    used.
  209.    */
  210.   virtual RecordWriter* createRecordWriter(ReduceContext& context) const {
  211.     return NULL;
  212.   }
  213.   virtual ~Factory() {}
  214. };
  215. /**
  216.  * Run the assigned task in the framework.
  217.  * The user's main function should set the various functions using the 
  218.  * set* functions above and then call this.
  219.  * @return true, if the task succeeded.
  220.  */
  221. bool runTask(const Factory& factory);
  222. }
  223. #endif