content: package backtype.storm.spout;
  
  import backtype.storm.task.OutputCollector;
  import backtype.storm.utils.Utils;
  import java.util.List;
  
  /**
   * This output collector exposes the API for emitting tuples from an {@link backtype.storm.topology.IRichSpout}.
   * The main difference between this output collector and {@link OutputCollector}
   * for {@link backtype.storm.topology.IRichBolt} is that spouts can tag messages with ids so that they can be
   * acked or failed later on. This is the Spout portion of Storm's API to
   * guarantee that each message is fully processed at least once.
   */
  public class SpoutOutputCollector implements ISpoutOutputCollector {
      ISpoutOutputCollector _delegate;
  
      public SpoutOutputCollector(ISpoutOutputCollector delegate) {
          _delegate = delegate;
      }
  
      /**
       * Emits a new tuple to the specified output stream with the given message ID.
       * When Storm detects that this tuple has been fully processed, or has failed
       * to be fully processed, the spout will receive an ack or fail callback respectively
       * with the messageId as long as the messageId was not null. If the messageId was null,
       * Storm will not track the tuple and no callback will be received.
       *
       * @return the list of task ids that this tuple was sent to
       */
      public List<Integer> emit(String streamId, List<Object> tuple, Object messageId) {
          return _delegate.emit(streamId, tuple, messageId);
      }
  
      /**
       * Emits a new tuple to the default output stream with the given message ID.
       * When Storm detects that this tuple has been fully processed, or has failed
       * to be fully processed, the spout will receive an ack or fail callback respectively
       * with the messageId as long as the messageId was not null. If the messageId was null,
       * Storm will not track the tuple and no callback will be received.
       *
       * @return the list of task ids that this tuple was sent to
       */
      public List<Integer> emit(List<Object> tuple, Object messageId) {
          return emit(Utils.DEFAULT_STREAM_ID, tuple, messageId);
      }
  
      /**
       * Emits a tuple to the default output stream with a null message id. Storm will
       * not track this message so ack and fail will never be called for this tuple.
       */
      public List<Integer> emit(List<Object> tuple) {
          return emit(tuple, null);
      }
  
      /**
       * Emits a tuple to the specified output stream with a null message id. Storm will
       * not track this message so ack and fail will never be called for this tuple.
       */
      public List<Integer> emit(String streamId, List<Object> tuple) {
          return emit(streamId, tuple, null);
      }
  
      /**
       * Emits a tuple to the specified task on the specified output stream. This output
       * stream must have been declared as a direct stream, and the specified task must
       * use a direct grouping on this stream to receive the message. 
       */
      public void emitDirect(int taskId, String streamId, List<Object> tuple, Object messageId) {
          _delegate.emitDirect(taskId, streamId, tuple, messageId);
      }
  
      /**
       * Emits a tuple to the specified task on the default output stream. This output
       * stream must have been declared as a direct stream, and the specified task must
       * use a direct grouping on this stream to receive the message.
       */
      public void emitDirect(int taskId, List<Object> tuple, Object messageId) {
          emitDirect(taskId, Utils.DEFAULT_STREAM_ID, tuple, messageId);
      }
      
      /**
       * Emits a tuple to the specified task on the specified output stream. This output
       * stream must have been declared as a direct stream, and the specified task must
       * use a direct grouping on this stream to receive the message.
       *
       * <p> Because no message id is specified, Storm will not track this message
       * so ack and fail will never be called for this tuple.</p>
       */
      public void emitDirect(int taskId, String streamId, List<Object> tuple) {
          emitDirect(taskId, streamId, tuple, null);
      }
  
      /**
       * Emits a tuple to the specified task on the default output stream. This output
       * stream must have been declared as a direct stream, and the specified task must
       * use a direct grouping on this stream to receive the message.
       *
       * <p> Because no message id is specified, Storm will not track this message
       * so ack and fail will never be called for this tuple.</p>
       */
      public void emitDirect(int taskId, List<Object> tuple) {
          emitDirect(taskId, tuple, null);
      }
  }
  