org.glassfish.grizzly.memory.WrapperAware.wrap 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

Returns Buffer, which wraps the String.

Popular methods of WrapperAware

Popular in Java

Making http requests using okhttp
compareTo (BigDecimal)
getApplicationContext (Context)
putExtra (Intent)
Date (java.sql)
A class which can consume and produce dates in SQL Date format. Dates are represented in SQL as yyyy
SimpleDateFormat (java.text)
Formats and parses dates in a locale-sensitive manner. Formatting turns a Date into a String, and pa
Arrays (java.util)
This class contains various methods for manipulating arrays (such as sorting and searching). This cl
List (java.util)
An ordered collection (also known as a sequence). The user of this interface has precise control ove
Locale (java.util)
Locale represents a language/country/variant combination. Locales are used to alter the presentatio
HttpServlet (javax.servlet.http)
Provides an abstract class to be subclassed to create an HTTP servlet suitable for a Web site. A sub
Top 15 Vim Plugins

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

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

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