org.qi4j.io.Output java code examples

Add the Codota plugin to your IDE and get smart completions

private void myMethod () {
 OutputStreamWriter o =OutputStream out;new OutputStreamWriter(out)
OutputStream out;String charsetName;new OutputStreamWriter(out, charsetName)
HttpURLConnection connection;new OutputStreamWriter(connection.getOutputStream())
Smart code suggestions by Codota
}

  @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>()

Javadoc

Output for data.

Most used methods

receiveFrom
This initiates a transfer from an Input. Implementations should open any resources to be written to

Popular in Java

Updating database using SQL prepared statement
compareTo (BigDecimal)
scheduleAtFixedRate (Timer)
notifyDataSetChanged (ArrayAdapter)
BufferedImage (java.awt.image)
The BufferedImage subclass describes an java.awt.Image with an accessible buffer of image data. All
ResultSet (java.sql)
An interface for an object which represents a database table entry, returned as the result of the qu
Scanner (java.util)
A parser that parses a text string of primitive types and strings with the help of regular expressio
TimerTask (java.util)
A task that can be scheduled for one-time or repeated execution by a Timer.
LogFactory (org.apache.commons.logging)
A minimal incarnation of Apache Commons Logging's LogFactory API, providing just the common Log look
DateTimeFormat (org.joda.time.format)
Factory that creates instances of DateTimeFormatter from patterns and styles. Datetime formatting i

How to useOutput in org.qi4j.io

Best Java code snippets using org.qi4j.io.Output (Showing top 20 results out of 315)

How to use
Output
in
org.qi4j.io