Examples of org.gudy.azureus2.core3.util.DirectByteBuffer

org.gudy.azureus2.core3.util.DirectByteBuffer
Virtual direct byte buffer given out and tracker by the buffer pool.

      if ( size == 0 ){
        
        continue;
      }
      
      DirectByteBuffer  target_buffer_db = DirectByteBufferPool.getBuffer( DirectByteBuffer.AL_NET_CRYPT,  size );
      
      try{
        ByteBuffer  target_buffer = target_buffer_db.getBuffer( DirectByteBuffer.SS_NET );
      
        cryptoOut( source_buffer, target_buffer );
        
        target_buffer.position( 0 );
        
        boolean  partial_write = false;
        
        for (int j=i+1;j<array_offset+length;j++){


          if ( buffers[j].hasRemaining()){
            
            partial_write = true;
          }
        }
        
        int  written = transport.write( target_buffer, partial_write );
        
        total_written += written;
        
        source_buffer.position( position + written );
        
        if ( written < size ){
          
          write_buffer_pending_db  = target_buffer_db;
          
          target_buffer_db  = null;
          
          if ( written == 0 ){
            
              // we gotta pretend at least 1 byte was written to
              // guarantee that the caller writes the rest
                      
            write_buffer_pending_byte = ByteBuffer.wrap(new byte[]{target_buffer.get()});
                          
            source_buffer.get();
            
            total_written++;
          }
          
          break;
        }
      }finally{
        
        if ( target_buffer_db != null ){
          
          target_buffer_db.returnToPool();
        }
      }
    }
    
    // System.out.println( "...write " + total_written );

View Full Code Here

  
  protected
  HTTPMessage(
    String  stuff )
  {
    data = new DirectByteBuffer[]{ new DirectByteBuffer( ByteBuffer.wrap( stuff.getBytes())) };
  }

View Full Code Here

  
  protected
  HTTPMessage(
    byte[]  stuff )
  {
    data = new DirectByteBuffer[]{ new DirectByteBuffer( ByteBuffer.wrap( stuff )) };
  }

View Full Code Here

  {
    offset  += file_offset_in_torrent;
    
    for (int i=0;i<buffers.length;i++){
      
      DirectByteBuffer  buffer = buffers[i];
      
      if ( AEDiagnostics.CHECK_DUMMY_FILE_DATA ){


        while( buffer.hasRemaining( DirectByteBuffer.SS_FILE )){
          
          byte  v = buffer.get( DirectByteBuffer.SS_FILE );
          
          if ((byte)offset != v ){
            
            System.out.println( "FMFileTest: write is bad at " + offset +
                      ": expected = " + (byte)offset + ", actual = " + v );
  
            offset += buffer.remaining( DirectByteBuffer.SS_FILE ) + 1;
            
            break;
          }
          
          offset++;
        }
      }
      
      buffer.position( DirectByteBuffer.SS_FILE, buffer.limit( DirectByteBuffer.SS_FILE ));
    }
  }

View Full Code Here

  
    throws FMFileManagerException
  {    
    for (int i=0;i<buffers.length;i++){
      
      DirectByteBuffer  buffer = buffers[i];
      
      int  len = buffers[i].limit(SS) - buffers[i].position(SS);
    
      read( raf, buffer, position );

View Full Code Here

  
    throws FMFileManagerException
  {    
    for (int i=0;i<buffers.length;i++){
      
      DirectByteBuffer  buffer = buffers[i];
      
      int  len = buffers[i].limit(SS) - buffers[i].position(SS);
    
      write( raf, buffer, position );

View Full Code Here

            Debug.out("data length inconsistent: len=" + data_length + ",limit=" + last_piece_length );
            
            data_length = last_piece_length;
          }
          
          DirectByteBuffer  buffer = 
            DirectByteBufferPool.getBuffer( DirectByteBuffer.AL_FILE, (int)data_length );
          
          try{
          
            file_access.read( raf, new DirectByteBuffer[]{ buffer }, last_piece_start );
            
              // see if we need to truncate
            
            if ( target_type == FMFile.FT_COMPACT ){
              
              long  first_piece_length = compact_access.getFirstPieceLength();
              
              long  physical_length = raf.length();
              
              if ( physical_length > first_piece_length ){
            
                raf.setLength( first_piece_length );
              }
            }
            
            buffer.flip( DirectByteBuffer.AL_FILE );
            
            target_access.write( raf, new DirectByteBuffer[]{ buffer }, last_piece_start );
            
          }finally{
            
            buffer.returnToPool();
          }
        }else{
          
            // no last piece, truncate after the first piece

View Full Code Here

    
    int[]  limits = new int[buffers.length];
  
    for ( int i=0;i<buffers.length;i++ ){
      
      DirectByteBuffer buffer = buffers[i];
      
      limits[i] = buffer.limit( SS_FILE );
      
      int  rem = buffer.remaining( SS_FILE );


      if ( rem > rem_space ){
        
        buffer.limit( SS_FILE, buffer.position( SS_FILE ) + rem_space );
        
        rem_space = 0;
        
      }else{

View Full Code Here

      
      if ( TRACE ){
        System.out.println( "    swapping " + piece_number + " and " + swap_piece_number + ": " + piece_number + " <-> " + store_index );
      }
      
      DirectByteBuffer temp_buffer = DirectByteBufferPool.getBuffer( SS_FILE, piece_size );
      
      DirectByteBuffer[] temp_buffers = new DirectByteBuffer[]{ temp_buffer };
      
      try{
        long  store_offset = first_piece_length + ((store_index-1)*(long)piece_size );
        long  swap_offset   = first_piece_length + ((piece_number-1)*(long)piece_size );
        
        delegate.read( raf, temp_buffers, swap_offset );
        
        piece_data.position( SS_FILE, 0 );
        
        delegate.write( raf, new DirectByteBuffer[]{ piece_data }, swap_offset );
        
        temp_buffer.position( SS_FILE, 0 );
        
        delegate.write( raf, temp_buffers, store_offset );
        
        piece_map[ piece_number ]       = piece_number;
        piece_reverse_map[ piece_number ]   = piece_number;
        
        piece_map[ swap_piece_number ]     = store_index;
        piece_reverse_map[ store_index ]   = swap_piece_number;
        
        setDirty();
        
        if ( piece_number == num_pieces - 1 ){
          
          long  file_length = swap_offset + last_piece_length;
          
          if ( delegate.getLength( raf ) > file_length ){
            
            if ( TRACE ){
              System.out.println( "    truncating file to correct length of " + file_length );
            }
            
            delegate.setLength( raf, file_length );
          }
        }
      }finally{
        
        temp_buffer.returnToPool();
      }
    }else{
      
      delegate.setPieceComplete( raf, piece_number, piece_data );
    }

View Full Code Here

          
          if ( TRACE ){
            System.out.println( "    piece number " + store_index + " already allocated at " + swap_index + ": moving piece ");
          }
                        
          DirectByteBuffer temp_buffer = DirectByteBufferPool.getBuffer( SS_FILE, piece_size );
          
          DirectByteBuffer[] temp_buffers = new DirectByteBuffer[]{ temp_buffer };
  
          try{
            long  store_offset   = first_piece_length + ((store_index-1)*(long)piece_size );
            long  swap_offset   = first_piece_length + ((swap_index-1)*(long)piece_size );


            delegate.read( raf, temp_buffers, swap_offset );


            temp_buffer.position( SS_FILE, 0 );
            
            delegate.write( raf, temp_buffers, store_offset );


            piece_map[ store_index ]       = store_index;
            piece_reverse_map[ store_index ]   = store_index;
            
            piece_map[ piece_number ]    = swap_index;
            piece_reverse_map[ swap_index ]  = piece_number;
                      
            if ( store_index == num_pieces - 1 ){
              
              long  file_length = store_offset + last_piece_length;
              
              if ( delegate.getLength( raf ) > file_length ){
                
                if ( TRACE ){
                  System.out.println( "    truncating file to correct length of " + file_length );
                }
                
                delegate.setLength( raf, file_length );
              }
            }
            
            store_index = swap_index;


          }finally{
            
            temp_buffer.returnToPool();
          }
        }
      }
      
      setDirty();

View Full Code Here

0 1 2 3 4 5 6 7 8 9

TOP

Related Classes of org.gudy.azureus2.core3.util.DirectByteBuffer

com.aelitis.azureus.core.diskmanager.access.DiskAccessRequestListener

com.aelitis.azureus.core.diskmanager.file.impl.FMFileAccessCompact

com.aelitis.azureus.core.diskmanager.file.impl.FMFileAccessPieceReorderer

com.aelitis.azureus.core.networkmanager.impl.http.HTTPMessage

com.aelitis.azureus.core.networkmanager.impl.http.HTTPNetworkConnection

com.aelitis.azureus.core.peermanager.messaging.Message

com.aelitis.azureus.core.peermanager.peerdb.PeerExchangerItem

com.aelitis.azureus.core.peermanager.piecepicker.util.BitFlags

com.aelitis.azureus.core.proxy.socks.impl.AESocksProxyPlugableConnectionDefault$proxyStateRelayData

com.aelitis.azureus.core.util.bloom.BloomFilter

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.