congrats Icon
New! Announcing Tabnine Chat Beta
Learn More
Tabnine Logo
Output
Code IndexAdd Tabnine to your IDE (free)

How to use
Output
in
org.qi4j.io

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

origin: org.qi4j.core/org.qi4j.core.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() );
        }
      }
    } );
  }
};
origin: org.qi4j.core/org.qi4j.core.io

  @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 );
        }
      }
    } );
  }
};
origin: org.qi4j.core/org.qi4j.core.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() );
        }
      }
    } );
  }
};
origin: org.qi4j.core/org.qi4j.core.io

  @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 ) );
          }
        } );
      }
    } );
  }
};
origin: org.qi4j.core/org.qi4j.core.io

  @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 );
            }
          }
        } );
      }
    } );
  }
};
origin: org.qi4j.library/org.qi4j.library.sql

@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;
        }
      } );
    }
  } );
}
origin: org.qi4j.library/org.qi4j.library.sql

@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;
        }
      } );
    }
  } );
}
origin: org.qi4j.core/org.qi4j.core.io

  @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 );
            }
          }
        } );
      }
    } );
  }
};
origin: org.qi4j.core/org.qi4j.core.io

throws SenderThrowableType, Receiver2ThrowableType
output.receiveFrom( new Sender<T, SenderThrowableType>()
origin: org.qi4j.core/org.qi4j.core.io

throws IOException, ReceiverThrowableType
output.receiveFrom( new Sender<ByteBuffer, IOException>()
origin: org.qi4j.core/org.qi4j.core.io

  @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();
    }
  }
};
origin: org.qi4j.library/org.qi4j.library.eventsourcing

  @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();
    }
  }
};
origin: org.qi4j.library/org.qi4j.library.eventsourcing

try
  output.receiveFrom( new Sender<TransactionApplicationEvents, IOException>()
origin: org.qi4j.core/org.qi4j.core.io

output.receiveFrom( sender );
origin: org.qi4j.library/org.qi4j.library.eventsourcing

try
  output.receiveFrom( new Sender<TransactionApplicationEvents, IOException>()
origin: org.qi4j.core/org.qi4j.core.io

  @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();
    }
  }
};
origin: org.qi4j.extension/org.qi4j.extension.entitystore-jdbm

output.receiveFrom( new Sender<Reader, IOException>()
origin: org.qi4j.extension/org.qi4j.extension.entitystore-jdbm

output.receiveFrom( new Sender<String, IOException>()
origin: org.qi4j.core/org.qi4j.core.io

  @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 );
          }
        }
      } );
    }
  }
};
origin: org.qi4j.core/org.qi4j.core.io

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

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

  • Making http requests using okhttp
  • runOnUiThread (Activity)
  • findViewById (Activity)
  • setRequestProperty (URLConnection)
  • Comparator (java.util)
    A Comparator is used to compare two objects to determine their ordering with respect to each other.
  • PriorityQueue (java.util)
    A PriorityQueue holds elements on a priority heap, which orders the elements according to their natu
  • Properties (java.util)
    A Properties object is a Hashtable where the keys and values must be Strings. Each property can have
  • ServletException (javax.servlet)
    Defines a general exception a servlet can throw when it encounters difficulty.
  • IOUtils (org.apache.commons.io)
    General IO stream manipulation utilities. This class provides static utility methods for input/outpu
  • Table (org.hibernate.mapping)
    A relational table
  • Top PhpStorm plugins
Tabnine Logo
  • Products

    Search for Java codeSearch for JavaScript code
  • IDE Plugins

    IntelliJ IDEAWebStormVisual StudioAndroid StudioEclipseVisual Studio CodePyCharmSublime TextPhpStormVimGoLandRubyMineEmacsJupyter NotebookJupyter LabRiderDataGripAppCode
  • Company

    About UsContact UsCareers
  • Resources

    FAQBlogTabnine AcademyTerms of usePrivacy policyJava Code IndexJavascript Code Index
Get Tabnine for your IDE now