How to use

Output

in

org.qi4j.io

  @Override
  public <ReceiverThrowableType extends Throwable> void transferTo( Output<? super String, ReceiverThrowableType> output )
    throws RuntimeException, ReceiverThrowableType
  {
    output.receiveFrom( new Sender<String, RuntimeException>()
    {
      @Override
      public <Receiver2ThrowableType extends Throwable> void sendTo( Receiver<? super String, Receiver2ThrowableType> receiver )
        throws Receiver2ThrowableType, RuntimeException
      {
        Scanner scanner = new Scanner( source );
        while( scanner.hasNextLine() )
        {
          receiver.receive( scanner.nextLine() );
        }
      }
    } );
  }
};

  @Override
  public <ReceiverThrowableType extends Throwable> void transferTo( Output<? super T, ReceiverThrowableType> output )
    throws RuntimeException, ReceiverThrowableType
  {
    output.receiveFrom( new Sender<T, RuntimeException>()
    {
      @Override
      public <Receiver2ThrowableType extends Throwable> void sendTo( Receiver<? super T, Receiver2ThrowableType> receiver )
        throws Receiver2ThrowableType, RuntimeException
      {
        for( T item : iterable )
        {
          receiver.receive( item );
        }
      }
    } );
  }
};

  @Override
  public <ReceiverThrowableType extends Throwable> void transferTo( Output<? super String, ReceiverThrowableType> output )
    throws RuntimeException, ReceiverThrowableType
  {
    output.receiveFrom( new Sender<String, RuntimeException>()
    {
      @Override
      public <Receiver2ThrowableType extends Throwable> void sendTo( Receiver<? super String, Receiver2ThrowableType> receiver )
        throws Receiver2ThrowableType, RuntimeException
      {
        Scanner scanner = new Scanner( source );
        while( scanner.hasNextLine() )
        {
          receiver.receive( scanner.nextLine() );
        }
      }
    } );
  }
};

  @Override
  public <SenderThrowableType extends Throwable> void receiveFrom( final Sender<? extends From, SenderThrowableType> sender )
    throws Receiver2ThrowableType, SenderThrowableType
  {
    output.receiveFrom( new Sender<To, SenderThrowableType>()
    {
      @Override
      public <ReceiverThrowableType extends Throwable> void sendTo( final Receiver<? super To, ReceiverThrowableType> receiver )
        throws ReceiverThrowableType, SenderThrowableType
      {
        sender.sendTo( new Receiver<From, ReceiverThrowableType>()
        {
          @Override
          public void receive( From item )
            throws ReceiverThrowableType
          {
            receiver.receive( function.map( item ) );
          }
        } );
      }
    } );
  }
};

  @Override
  public <SenderThrowableType extends Throwable> void receiveFrom( final Sender<? extends T, SenderThrowableType> sender )
    throws Receiver2ThrowableType, SenderThrowableType
  {
    output.receiveFrom( new Sender<T, SenderThrowableType>()
    {
      @Override
      public <ReceiverThrowableType extends Throwable> void sendTo( final Receiver<? super T, ReceiverThrowableType> receiver )
        throws ReceiverThrowableType, SenderThrowableType
      {
        sender.sendTo( new Receiver<T, ReceiverThrowableType>()
        {
          @Override
          public void receive( T item )
            throws ReceiverThrowableType
          {
            if( specification.satisfiedBy( item ) )
            {
              receiver.receive( item );
            }
          }
        } );
      }
    } );
  }
};

@Override
public <ReceiverThrowableType extends Throwable> void transferTo( Output<? super ResultSet, ReceiverThrowableType> output )
    throws SQLException, ReceiverThrowableType
{
  output.receiveFrom( new Sender<ResultSet, SQLException>()
  {
    @Override
    public <ReceiverThrowableType extends Throwable> void sendTo( final Receiver<? super ResultSet, ReceiverThrowableType> receiver )
        throws ReceiverThrowableType, SQLException
    {
      query( sql, visitor, new ResultSetVisitor()
      {
        @Override
        public boolean visit( ResultSet visited )
            throws SQLException
        {
          try {
            receiver.receive( visited );
          } catch ( Throwable receiverThrowableType ) {
            throw new SQLException( receiverThrowableType );
          }
          return true;
        }
      } );
    }
  } );
}

@Override
public <ReceiverThrowableType extends Throwable> void transferTo( Output<? super ResultSet, ReceiverThrowableType> output )
    throws SQLException, ReceiverThrowableType
{
  output.receiveFrom( new Sender<ResultSet, SQLException>()
  {
    @Override
    public <ReceiverThrowableType extends Throwable> void sendTo( final Receiver<? super ResultSet, ReceiverThrowableType> receiver )
        throws ReceiverThrowableType, SQLException
    {
      query( sql, new ResultSetVisitor()
      {
        @Override
        public boolean visit( ResultSet visited )
            throws SQLException
        {
          try {
            receiver.receive( visited );
          } catch ( Throwable receiverThrowableType ) {
            throw new SQLException( receiverThrowableType );
          }
          return true;
        }
      } );
    }
  } );
}

  @Override
  public <SenderThrowableType extends Throwable> void receiveFrom( final Sender<? extends T, SenderThrowableType> sender )
    throws Receiver2ThrowableType, SenderThrowableType
  {
    output.receiveFrom( new Sender<T, SenderThrowableType>()
    {
      @Override
      public <ReceiverThrowableType extends Throwable> void sendTo( final Receiver<? super T, ReceiverThrowableType> receiver )
        throws ReceiverThrowableType, SenderThrowableType
      {
        sender.sendTo( new Receiver<T, ReceiverThrowableType>()
        {
          @Override
          public void receive( T item )
            throws ReceiverThrowableType
          {
            if( specification.satisfiedBy( item ) )
            {
              receiver.receive( function.map( item ) );
            }
            else
            {
              receiver.receive( item );
            }
          }
        } );
      }
    } );
  }
};

throws SenderThrowableType, Receiver2ThrowableType
output.receiveFrom( new Sender<T, SenderThrowableType>()

throws IOException, ReceiverThrowableType
output.receiveFrom( new Sender<ByteBuffer, IOException>()

  @Override
  public <ReceiverThrowableType extends Throwable> void transferTo( Output<? super ByteBuffer, ReceiverThrowableType> output )
    throws IOException, ReceiverThrowableType
  {
    try
    {
      output.receiveFrom( new Sender<ByteBuffer, IOException>()
      {
        @Override
        public <Receiver2ThrowableType extends Throwable> void sendTo( Receiver<? super ByteBuffer, Receiver2ThrowableType> receiver )
          throws Receiver2ThrowableType, IOException
        {
          byte[] buffer = new byte[ bufferSize ];
          int len;
          while( ( len = source.read( buffer ) ) != -1 )
          {
            ByteBuffer byteBuffer = ByteBuffer.wrap( buffer, 0, len );
            receiver.receive( byteBuffer );
          }
        }
      } );
    }
    finally
    {
      source.close();
    }
  }
};

  @Override
  public <ReceiverThrowableType extends Throwable> void transferTo( Output<? super UnitOfWorkDomainEventsValue, ReceiverThrowableType> output ) throws IOException, ReceiverThrowableType
  {
    // Lock store first
    lock.lock();
    try
    {
      output.receiveFrom( new Sender<UnitOfWorkDomainEventsValue, IOException>()
      {
        @Override
        public <ReceiverThrowableType extends Throwable> void sendTo( Receiver<? super UnitOfWorkDomainEventsValue, ReceiverThrowableType> receiver ) throws ReceiverThrowableType, IOException
        {
          ListIterator<UnitOfWorkDomainEventsValue> iterator = store.listIterator( (int) offset );
          long count = 0;
          while( iterator.hasNext() && count < limit )
          {
            UnitOfWorkDomainEventsValue next = iterator.next();
            receiver.receive( next );
            count++;
          }
        }
      } );
    } finally
    {
      lock.unlock();
    }
  }
};

try
  output.receiveFrom( new Sender<TransactionApplicationEvents, IOException>()

output.receiveFrom( sender );

try
  output.receiveFrom( new Sender<TransactionApplicationEvents, IOException>()

  @Override
  public <ReceiverThrowableType extends Throwable> void transferTo( Output<? super ByteBuffer, ReceiverThrowableType> output )
    throws IOException, ReceiverThrowableType
  {
    final FileInputStream stream = new FileInputStream( source );
    final FileChannel fci = stream.getChannel();
    final ByteBuffer buffer = ByteBuffer.allocate( bufferSize );
    try
    {
      output.receiveFrom( new Sender<ByteBuffer, IOException>()
      {
        @Override
        public <Receiver2ThrowableType extends Throwable> void sendTo( Receiver<? super ByteBuffer, Receiver2ThrowableType> receiver )
          throws Receiver2ThrowableType, IOException
        {
          while( fci.read( buffer ) != -1 )
          {
            buffer.flip();
            receiver.receive( buffer );
            buffer.clear();
          }
        }
      } );
    }
    finally
    {
      stream.close();
    }
  }
};

output.receiveFrom( new Sender<Reader, IOException>()

output.receiveFrom( new Sender<String, IOException>()

  @Override
  public <ReceiverThrowableType extends Throwable> void transferTo( Output<? super String, ReceiverThrowableType> output )
    throws IOException, ReceiverThrowableType
  {
    InputStream stream = new FileInputStream( source );
    // If file is gzipped, unzip it automatically
    if( source.getName().endsWith( ".gz" ) )
    {
      stream = new GZIPInputStream( stream );
    }
    try (BufferedReader reader = new BufferedReader( new InputStreamReader( stream, encoding ) ))
    {
      output.receiveFrom( new Sender<String, IOException>()
      {
        @Override
        public <Receiver2ThrowableType extends Throwable> void sendTo( Receiver<? super String, Receiver2ThrowableType> receiver )
          throws Receiver2ThrowableType, IOException
        {
          String line;
          while( ( line = reader.readLine() ) != null )
          {
            receiver.receive( line );
          }
        }
      } );
    }
  }
};

output.receiveFrom( new Sender<String, IOException>()