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 Tabnine
}

  @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

Finding current android device location
scheduleAtFixedRate (ScheduledExecutorService)
putExtra (Intent)
getResourceAsStream (ClassLoader)
System (java.lang)
Provides access to system-related information and resources including standard input and output. Ena
Map (java.util)
A Map is a data structure consisting of a set of keys and values in which each key is mapped to a si
NoSuchElementException (java.util)
Thrown when trying to retrieve an element past the end of an Enumeration or Iterator.
AtomicInteger (java.util.concurrent.atomic)
An int value that may be updated atomically. See the java.util.concurrent.atomic package specificati
XPath (javax.xml.xpath)
XPath provides access to the XPath evaluation environment and expressions. Evaluation of XPath Expr
FileUtils (org.apache.commons.io)
General file manipulation utilities. Facilities are provided in the following areas: * writing to a
Sublime Text for Python

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