org.glassfish.grizzly.memory.WrapperAware java code examples

Add the Codota plugin to your IDE and get smart completions

private void myMethod () {
 List l =new LinkedList()
Collections.emptyList()
new ArrayList()
Smart code suggestions by Tabnine
}

/**
 * Returns {@link Buffer}, which wraps the {@link ByteBuffer}.
 *
 * @param memoryManager {@link MemoryManager}, which should be
 *                       used for wrapping.
 * @param byteBuffer {@link ByteBuffer} to wrap
 *
 * @return {@link Buffer} wrapper on top of passed {@link ByteBuffer}.
 */
public static Buffer wrap(final MemoryManager memoryManager,
    final ByteBuffer byteBuffer) {
  if (memoryManager instanceof WrapperAware) {
    return ((WrapperAware) memoryManager).wrap(byteBuffer);
  } else if (byteBuffer.hasArray()) {
    return wrap(memoryManager, byteBuffer.array(),
        byteBuffer.arrayOffset() + byteBuffer.position(),
        byteBuffer.remaining());
  }
  throw new IllegalStateException("Can not wrap ByteBuffer");
}

/**
 * Returns {@link Buffer}, which wraps the {@link ByteBuffer}.
 *
 * @param memoryManager {@link MemoryManager}, which should be
 *                       used for wrapping.
 * @param byteBuffer {@link ByteBuffer} to wrap
 *
 * @return {@link Buffer} wrapper on top of passed {@link ByteBuffer}.
 */
public static Buffer wrap(final MemoryManager memoryManager,
    final ByteBuffer byteBuffer) {
  if (memoryManager instanceof WrapperAware) {
    return ((WrapperAware) memoryManager).wrap(byteBuffer);
  } else if (byteBuffer.hasArray()) {
    return wrap(memoryManager, byteBuffer.array(),
        byteBuffer.arrayOffset() + byteBuffer.position(),
        byteBuffer.remaining());
  }
  throw new IllegalStateException("Can not wrap ByteBuffer");
}

/**
 * Returns {@link Buffer}, which wraps the {@link ByteBuffer}.
 *
 * @param memoryManager {@link MemoryManager}, which should be
 *                       used for wrapping.
 * @param byteBuffer {@link ByteBuffer} to wrap
 *
 * @return {@link Buffer} wrapper on top of passed {@link ByteBuffer}.
 */
public static Buffer wrap(final MemoryManager memoryManager,
    final ByteBuffer byteBuffer) {
  if (memoryManager instanceof WrapperAware) {
    return ((WrapperAware) memoryManager).wrap(byteBuffer);
  } else if (byteBuffer.hasArray()) {
    return wrap(memoryManager, byteBuffer.array(),
        byteBuffer.arrayOffset() + byteBuffer.position(),
        byteBuffer.remaining());
  }
  throw new IllegalStateException("Can not wrap ByteBuffer");
}

/**
 * Returns {@link Buffer}, which wraps the {@link ByteBuffer}.
 *
 * @param memoryManager {@link MemoryManager}, which should be
 *                       used for wrapping.
 * @param byteBuffer {@link ByteBuffer} to wrap
 *
 * @return {@link Buffer} wrapper on top of passed {@link ByteBuffer}.
 */
public static Buffer wrap(final MemoryManager memoryManager,
    final ByteBuffer byteBuffer) {
  if (memoryManager instanceof WrapperAware) {
    return ((WrapperAware) memoryManager).wrap(byteBuffer);
  } else if (byteBuffer.hasArray()) {
    return wrap(memoryManager, byteBuffer.array(),
        byteBuffer.arrayOffset() + byteBuffer.position(),
        byteBuffer.remaining());
  }
  throw new IllegalStateException("Can not wrap ByteBuffer");
}

/**
 * Returns {@link Buffer}, which wraps the {@link ByteBuffer}.
 *
 * @param memoryManager {@link MemoryManager}, which should be
 *                       used for wrapping.
 * @param byteBuffer {@link ByteBuffer} to wrap
 *
 * @return {@link Buffer} wrapper on top of passed {@link ByteBuffer}.
 */
public static Buffer wrap(final MemoryManager memoryManager,
    final ByteBuffer byteBuffer) {
  if (memoryManager instanceof WrapperAware) {
    return ((WrapperAware) memoryManager).wrap(byteBuffer);
  } else if (byteBuffer.hasArray()) {
    return wrap(memoryManager, byteBuffer.array(),
        byteBuffer.arrayOffset() + byteBuffer.position(),
        byteBuffer.remaining());
  }
  throw new IllegalStateException("Can not wrap ByteBuffer");
}

/**
 * Returns {@link Buffer}, which wraps the {@link ByteBuffer}.
 *
 * @param memoryManager {@link MemoryManager}, which should be
 *                       used for wrapping.
 * @param byteBuffer {@link ByteBuffer} to wrap
 *
 * @return {@link Buffer} wrapper on top of passed {@link ByteBuffer}.
 */
public static Buffer wrap(final MemoryManager memoryManager,
    final ByteBuffer byteBuffer) {
  if (memoryManager instanceof WrapperAware) {
    return ((WrapperAware) memoryManager).wrap(byteBuffer);
  } else if (byteBuffer.hasArray()) {
    return wrap(memoryManager, byteBuffer.array(),
        byteBuffer.arrayOffset() + byteBuffer.position(),
        byteBuffer.remaining());
  }
  throw new IllegalStateException("Can not wrap ByteBuffer");
}

/**
 * Returns {@link Buffer}, which wraps the {@link ByteBuffer}.
 *
 * @param memoryManager {@link MemoryManager}, which should be
 *                       used for wrapping.
 * @param byteBuffer {@link ByteBuffer} to wrap
 *
 * @return {@link Buffer} wrapper on top of passed {@link ByteBuffer}.
 */
public static Buffer wrap(final MemoryManager memoryManager,
    final ByteBuffer byteBuffer) {
  if (memoryManager instanceof WrapperAware) {
    return ((WrapperAware) memoryManager).wrap(byteBuffer);
  } else if (byteBuffer.hasArray()) {
    return wrap(memoryManager, byteBuffer.array(),
        byteBuffer.arrayOffset() + byteBuffer.position(),
        byteBuffer.remaining());
  }
  throw new IllegalStateException("Can not wrap ByteBuffer");
}

/**
 * Returns {@link Buffer}, which wraps the {@link ByteBuffer}.
 *
 * @param memoryManager {@link MemoryManager}, which should be
 *                       used for wrapping.
 * @param byteBuffer {@link ByteBuffer} to wrap
 *
 * @return {@link Buffer} wrapper on top of passed {@link ByteBuffer}.
 */
public static Buffer wrap(final MemoryManager memoryManager,
    final ByteBuffer byteBuffer) {
  if (memoryManager instanceof WrapperAware) {
    return ((WrapperAware) memoryManager).wrap(byteBuffer);
  } else if (byteBuffer.hasArray()) {
    return wrap(memoryManager, byteBuffer.array(),
        byteBuffer.arrayOffset() + byteBuffer.position(),
        byteBuffer.remaining());
  }
  throw new IllegalStateException("Can not wrap ByteBuffer");
}

/**
 * Returns {@link Buffer}, which wraps the {@link ByteBuffer}.
 *
 * @param memoryManager {@link MemoryManager}, which should be
 *                       used for wrapping.
 * @param byteBuffer {@link ByteBuffer} to wrap
 *
 * @return {@link Buffer} wrapper on top of passed {@link ByteBuffer}.
 */
public static Buffer wrap(final MemoryManager memoryManager,
    final ByteBuffer byteBuffer) {
  if (memoryManager instanceof WrapperAware) {
    return ((WrapperAware) memoryManager).wrap(byteBuffer);
  } else if (byteBuffer.hasArray()) {
    return wrap(memoryManager, byteBuffer.array(),
        byteBuffer.arrayOffset() + byteBuffer.position(),
        byteBuffer.remaining());
  }
  throw new IllegalStateException("Can not wrap ByteBuffer");
}

/**
 * Returns {@link Buffer}, which wraps the {@link ByteBuffer}.
 *
 * @param memoryManager {@link MemoryManager}, which should be
 *                       used for wrapping.
 * @param byteBuffer {@link ByteBuffer} to wrap
 *
 * @return {@link Buffer} wrapper on top of passed {@link ByteBuffer}.
 */
public static Buffer wrap(final MemoryManager memoryManager,
    final ByteBuffer byteBuffer) {
  if (memoryManager instanceof WrapperAware) {
    return ((WrapperAware) memoryManager).wrap(byteBuffer);
  } else if (byteBuffer.hasArray()) {
    return wrap(memoryManager, byteBuffer.array(),
        byteBuffer.arrayOffset() + byteBuffer.position(),
        byteBuffer.remaining());
  }
  throw new IllegalStateException("Can not wrap ByteBuffer");
}

/**
 * Returns {@link Buffer}, which wraps the {@link ByteBuffer}.
 *
 * @param memoryManager {@link MemoryManager}, which should be
 *                       used for wrapping.
 * @param byteBuffer {@link ByteBuffer} to wrap
 *
 * @return {@link Buffer} wrapper on top of passed {@link ByteBuffer}.
 */
public static Buffer wrap(final MemoryManager memoryManager,
    final ByteBuffer byteBuffer) {
  if (memoryManager instanceof WrapperAware) {
    return ((WrapperAware) memoryManager).wrap(byteBuffer);
  } else if (byteBuffer.hasArray()) {
    return wrap(memoryManager, byteBuffer.array(),
        byteBuffer.arrayOffset() + byteBuffer.position(),
        byteBuffer.remaining());
  }
  throw new IllegalStateException("Can not wrap ByteBuffer");
}

/**
 * Returns {@link Buffer}, which wraps the {@link ByteBuffer}.
 *
 * @param memoryManager {@link MemoryManager}, which should be
 *                       used for wrapping.
 * @param byteBuffer {@link ByteBuffer} to wrap
 *
 * @return {@link Buffer} wrapper on top of passed {@link ByteBuffer}.
 */
public static Buffer wrap(final MemoryManager memoryManager,
    final ByteBuffer byteBuffer) {
  if (memoryManager instanceof WrapperAware) {
    return ((WrapperAware) memoryManager).wrap(byteBuffer);
  } else if (byteBuffer.hasArray()) {
    return wrap(memoryManager, byteBuffer.array(),
        byteBuffer.arrayOffset() + byteBuffer.position(),
        byteBuffer.remaining());
  }
  throw new IllegalStateException("Can not wrap ByteBuffer");
}

/**
 * Returns {@link Buffer}, which wraps the part of byte array with
 * specific offset and length.
 *
 * @param memoryManager {@link MemoryManager}, which should be
 *                       used for wrapping.
 * @param array byte array to wrap
 * @param offset byte buffer offset
 * @param length byte buffer length
 *
 * @return {@link Buffer} wrapper on top of passed byte array.
 */
public static Buffer wrap(MemoryManager memoryManager,
    final byte[] array, final int offset, final int length) {
  if (memoryManager == null) {
    memoryManager = getDefaultMemoryManager();
  }
  if (memoryManager instanceof WrapperAware) {
    return ((WrapperAware) memoryManager).wrap(array, offset, length);
  }
  final Buffer buffer = memoryManager.allocate(length);
  buffer.put(array, offset, length);
  buffer.flip();
  return buffer;
}

/**
 * Returns {@link Buffer}, which wraps the part of byte array with
 * specific offset and length.
 *
 * @param memoryManager {@link MemoryManager}, which should be
 *                       used for wrapping.
 * @param array byte array to wrap
 * @param offset byte buffer offset
 * @param length byte buffer length
 *
 * @return {@link Buffer} wrapper on top of passed byte array.
 */
public static Buffer wrap(MemoryManager memoryManager,
    final byte[] array, final int offset, final int length) {
  if (memoryManager == null) {
    memoryManager = getDefaultMemoryManager();
  }
  if (memoryManager instanceof WrapperAware) {
    return ((WrapperAware) memoryManager).wrap(array, offset, length);
  }
  final Buffer buffer = memoryManager.allocate(length);
  buffer.put(array, offset, length);
  buffer.flip();
  return buffer;
}

/**
 * Returns {@link Buffer}, which wraps the part of byte array with
 * specific offset and length.
 *
 * @param memoryManager {@link MemoryManager}, which should be
 *                       used for wrapping.
 * @param array byte array to wrap
 * @param offset byte buffer offset
 * @param length byte buffer length
 *
 * @return {@link Buffer} wrapper on top of passed byte array.
 */
public static Buffer wrap(MemoryManager memoryManager,
    final byte[] array, final int offset, final int length) {
  if (memoryManager == null) {
    memoryManager = getDefaultMemoryManager();
  }
  if (memoryManager instanceof WrapperAware) {
    return ((WrapperAware) memoryManager).wrap(array, offset, length);
  }
  final Buffer buffer = memoryManager.allocate(length);
  buffer.put(array, offset, length);
  buffer.flip();
  return buffer;
}

/**
 * Returns {@link Buffer}, which wraps the part of byte array with
 * specific offset and length.
 *
 * @param memoryManager {@link MemoryManager}, which should be
 *                       used for wrapping.
 * @param array byte array to wrap
 * @param offset byte buffer offset
 * @param length byte buffer length
 *
 * @return {@link Buffer} wrapper on top of passed byte array.
 */
public static Buffer wrap(MemoryManager memoryManager,
    final byte[] array, final int offset, final int length) {
  if (memoryManager == null) {
    memoryManager = getDefaultMemoryManager();
  }
  if (memoryManager instanceof WrapperAware) {
    return ((WrapperAware) memoryManager).wrap(array, offset, length);
  }
  final Buffer buffer = memoryManager.allocate(length);
  buffer.put(array, offset, length);
  buffer.flip();
  return buffer;
}

/**
 * Returns {@link Buffer}, which wraps the part of byte array with
 * specific offset and length.
 *
 * @param memoryManager {@link MemoryManager}, which should be
 *                       used for wrapping.
 * @param array byte array to wrap
 * @param offset byte buffer offset
 * @param length byte buffer length
 *
 * @return {@link Buffer} wrapper on top of passed byte array.
 */
public static Buffer wrap(MemoryManager memoryManager,
    final byte[] array, final int offset, final int length) {
  if (memoryManager == null) {
    memoryManager = getDefaultMemoryManager();
  }
  if (memoryManager instanceof WrapperAware) {
    return ((WrapperAware) memoryManager).wrap(array, offset, length);
  }
  final Buffer buffer = memoryManager.allocate(length);
  buffer.put(array, offset, length);
  buffer.flip();
  return buffer;
}

/**
 * Returns {@link Buffer}, which wraps the part of byte array with
 * specific offset and length.
 *
 * @param memoryManager {@link MemoryManager}, which should be
 *                       used for wrapping.
 * @param array byte array to wrap
 * @param offset byte buffer offset
 * @param length byte buffer length
 *
 * @return {@link Buffer} wrapper on top of passed byte array.
 */
public static Buffer wrap(MemoryManager memoryManager,
    final byte[] array, final int offset, final int length) {
  if (memoryManager == null) {
    memoryManager = getDefaultMemoryManager();
  }
  if (memoryManager instanceof WrapperAware) {
    return ((WrapperAware) memoryManager).wrap(array, offset, length);
  }
  final Buffer buffer = memoryManager.allocate(length);
  buffer.put(array, offset, length);
  buffer.flip();
  return buffer;
}

/**
 * Returns {@link Buffer}, which wraps the part of byte array with
 * specific offset and length.
 *
 * @param memoryManager {@link MemoryManager}, which should be
 *                       used for wrapping.
 * @param array byte array to wrap
 * @param offset byte buffer offset
 * @param length byte buffer length
 *
 * @return {@link Buffer} wrapper on top of passed byte array.
 */
public static Buffer wrap(MemoryManager memoryManager,
    final byte[] array, final int offset, final int length) {
  if (memoryManager == null) {
    memoryManager = getDefaultMemoryManager();
  }
  if (memoryManager instanceof WrapperAware) {
    return ((WrapperAware) memoryManager).wrap(array, offset, length);
  }
  final Buffer buffer = memoryManager.allocate(length);
  buffer.put(array, offset, length);
  buffer.flip();
  return buffer;
}

/**
 * Returns {@link Buffer}, which wraps the part of byte array with
 * specific offset and length.
 *
 * @param memoryManager {@link MemoryManager}, which should be
 *                       used for wrapping.
 * @param array byte array to wrap
 * @param offset byte buffer offset
 * @param length byte buffer length
 *
 * @return {@link Buffer} wrapper on top of passed byte array.
 */
public static Buffer wrap(MemoryManager memoryManager,
    final byte[] array, final int offset, final int length) {
  if (memoryManager == null) {
    memoryManager = getDefaultMemoryManager();
  }
  if (memoryManager instanceof WrapperAware) {
    return ((WrapperAware) memoryManager).wrap(array, offset, length);
  }
  final Buffer buffer = memoryManager.allocate(length);
  buffer.put(array, offset, length);
  buffer.flip();
  return buffer;
}

Javadoc

MemoryManagers, which implement this interface, are able to convert frequently used Java buffer types to Grizzly Buffer.

Most used methods

wrap
Returns Buffer, which wraps the part of byte array with specific offset and length.

Popular in Java

Start an intent from android
notifyDataSetChanged (ArrayAdapter)
getOriginalFilename (MultipartFile)
Return the original filename in the client's filesystem.This may contain path information depending
runOnUiThread (Activity)
Thread (java.lang)
A thread is a thread of execution in a program. The Java Virtual Machine allows an application to ha
SocketTimeoutException (java.net)
This exception is thrown when a timeout expired on a socket read or accept operation.
ByteBuffer (java.nio)
A buffer for bytes. A byte buffer can be created in either one of the following ways: * #allocate
NumberFormat (java.text)
The abstract base class for all number formats. This class provides the interface for formatting and
ExecutorService (java.util.concurrent)
An Executor that provides methods to manage termination and methods that can produce a Future for tr
SAXParseException (org.xml.sax)
Encapsulate an XML parse error or warning.> This module, both source code and documentation, is in t
21 Best IntelliJ Plugins

How to useWrapperAware in org.glassfish.grizzly.memory

Best Java code snippets using org.glassfish.grizzly.memory.WrapperAware (Showing top 20 results out of 315)

How to use
WrapperAware
in
org.glassfish.grizzly.memory