src/org/jnetpcap/nio/JMemory.java
private int peer0(long peerAddress, int length, Object keeper)
			throws IndexOutOfBoundsException {

		if (peerAddress != this.physical) {
			cleanup();
		}

		this.physical = peerAddress;
		this.size = length;

		/**
		 * For specific reasons, we can never be the owner of the peered structure.
		 * The owner should remain the object that initially created or was created
		 * to manage the physical memory. The reasons are as follows:
		 * <ul>
		 * <li>Memory could be a revolving buffer
		 * <li>Memory allocation could have been complex with sub structures that
		 * need to be deallocated
		 * <li>The src object may have been passed around and references stored to
		 * it elsewhere. If we are GCed before src and we free up the memory the
		 * original src object would become unstable
		 * </ul>
		 */

		this.keeper = keeper;

		return size;
	}
/**
	 * Peers the peer structure with this instance. The physical memory that the
	 * peer object points to is set to this instance. The owner flag is not copied
	 * and peer remains at the same state as it did before. This instance does not
	 * become the owner of the memory. The function allows peering to a sub
	 * portion of the peer given the specified offset and length. The function
	 * strictly checks and inforces the bounds of the request to guarrantee that
	 * peer is not allowed to access physical memory outside of actual peer range.
	 * 
	 * @param peerAddress
	 *          the peer address
	 * @param length
	 *          amount of memory to peer with
	 * @param keeper
	 *          the keeper
	 * @return the int
	 * @throws IndexOutOfBoundsException
	 *           if the specified memory offset and length have negative or out of
	 *           bounds of peer objects address space
	 */
Peers the peer structure with this instance. The physical memory that the
peer object points to is set to this instance. The owner flag is not copied
and peer remains at the same state as it did before. This instance does not
become the owner of the memory. The function allows peering to a sub
portion of the peer given the specified offset and length. The function
strictly checks and inforces the bounds of the request to guarrantee that
peer is not allowed to access physical memory outside of actual peer range.


Peers the peer structure with this instance . The physical memory that the peer object points to is set to this instance . The owner flag is not copied and peer remains at the same state as it did before . This instance does not become the owner of the memory . The function allows peering to a sub portion of the peer given the specified offset and length . The function strictly checks and inforces the bounds of the request to guarrantee that peer is not allowed to access physical memory outside of actual peer range .
private int peer0(long peerAddress, int length, Object keeper)
			throws IndexOutOfBoundsException {
		if (peerAddress != this.physical) {
			cleanup();
		}
		this.physical = peerAddress;
		this.size = length;
		/**
		 * For specific reasons, we can never be the owner of the peered structure.
		 * The owner should remain the object that initially created or was created
		 * to manage the physical memory. The reasons are as follows:
		 * <ul>
		 * <li>Memory could be a revolving buffer
		 * <li>Memory allocation could have been complex with sub structures that
		 * need to be deallocated
		 * <li>The src object may have been passed around and references stored to
		 * it elsewhere. If we are GCed before src and we free up the memory the
		 * original src object would become unstable
		 * </ul>
		 */
		this.keeper = keeper;
		return size;
	}
private int peer0 ( long peerAddress , int length , Object keeper ) throws IndexOutOfBoundsException { if ( peerAddress != this . physical ) { cleanup ( ) ; } this . physical = peerAddress ; this . size = length ; /**
		 * For specific reasons, we can never be the owner of the peered structure.
		 * The owner should remain the object that initially created or was created
		 * to manage the physical memory. The reasons are as follows:
		 * <ul>
		 * <li>Memory could be a revolving buffer
		 * <li>Memory allocation could have been complex with sub structures that
		 * need to be deallocated
		 * <li>The src object may have been passed around and references stored to
		 * it elsewhere. If we are GCed before src and we free up the memory the
		 * original src object would become unstable
		 * </ul>
		 */ this . keeper = keeper ; return size ; }
Peers the peer structure with this instance.
Peers the peer structure with this instance .