Java Code Examples for io.netty.util.internal.TypeParameterMatcher#get()

ReliableChannelHandler() {
  matcher = TypeParameterMatcher.get(DatagramPacket.class);
}
 

public EndpointedChannelHandler(Class<T> packetType, Endpoint<T> endpoint) {
  this.endpoint = endpoint;
  matcher = TypeParameterMatcher.get(packetType);
}
 

public ReliableChannelHandler(ReliableEndpoint endpoint) {
  this.endpoint = endpoint;
  matcher = TypeParameterMatcher.get(DatagramPacket.class);
}
 

public EndpointedChannelHandler(boolean autoRelease, Class<T> packetType, Endpoint<T> endpoint) {
  this.autoRelease = autoRelease;
  this.endpoint = endpoint;
  matcher = TypeParameterMatcher.get(packetType);
}
 

public OutboundBlackholeHandler(Class<? extends T> outboundMessageType) {
    matcher = TypeParameterMatcher.get(outboundMessageType);
}
 

/**
 * Create a handler publisher.
 *
 * The supplied executor must be the same event loop as the event loop that this handler is eventually registered
 * with, if not, an exception will be thrown when the handler is registered.
 *
 * @param executor The executor to execute asynchronous events from the subscriber on.
 * @param subscriberMessageType The type of message this publisher accepts.
 */
public HandlerPublisher(EventExecutor executor, Class<? extends T> subscriberMessageType) {
    this.executor = executor;
    this.matcher = TypeParameterMatcher.get(subscriberMessageType);
}
 

/**
 * Create a new instance.
 *
 * @param inboundMessageType    The type of messages to decode
 * @param outboundMessageType   The type of messages to encode
 */
protected MessageToMessageCodec(
        Class<? extends INBOUND_IN> inboundMessageType, Class<? extends OUTBOUND_IN> outboundMessageType) {
    inboundMsgMatcher = TypeParameterMatcher.get(inboundMessageType);
    outboundMsgMatcher = TypeParameterMatcher.get(outboundMessageType);
}
 

/**
 * Create a new instance
 *
 * @param inboundMessageType    The type of messages to match and so decode
 */
protected MessageToMessageDecoder(Class<? extends I> inboundMessageType) {
    matcher = TypeParameterMatcher.get(inboundMessageType);
}
 

/**
 * Create a new instance
 *
 * @param outboundMessageType   The type of messages to match and so encode
 */
protected MessageToMessageEncoder(Class<? extends I> outboundMessageType) {
    matcher = TypeParameterMatcher.get(outboundMessageType);
}
 

/**
 * Create a new instance
 *
 * @param outboundMessageType   The type of messages to match
 * @param preferDirect          {@code true} if a direct {@link ByteBuf} should be tried to be used as target for
 *                              the encoded messages. If {@code false} is used it will allocate a heap
 *                              {@link ByteBuf}, which is backed by an byte array.
 */
protected ByteToMessageCodec(Class<? extends I> outboundMessageType, boolean preferDirect) {
    CodecUtil.ensureNotSharable(this);
    outboundMsgMatcher = TypeParameterMatcher.get(outboundMessageType);
    encoder = new Encoder(preferDirect);
}
 

/**
 * Create a new instance
 *
 * @param inboundMessageType    The type of messages to match
 * @param autoRelease           {@code true} if handled messages should be released automatically by pass them to
 *                              {@link ReferenceCountUtil#release(Object)}.
 */
protected SimpleChannelInboundHandler(Class<? extends I> inboundMessageType, boolean autoRelease) {
    matcher = TypeParameterMatcher.get(inboundMessageType);
    this.autoRelease = autoRelease;
}
 

/**
 * Create a new instance
 *
 * @param inboundMessageType    The type of messages to match
 * @param autoRelease           {@code true} if handled messages should be released automatically by passing them to
 *                              {@link ReferenceCountUtil#release(Object)}.
 */
protected SimpleChannelInboundHandler(Class<? extends I> inboundMessageType, boolean autoRelease) {
    matcher = TypeParameterMatcher.get(inboundMessageType);
    this.autoRelease = autoRelease;
}
 

/**
 * Create a new instance
 *
 * @param outboundMessageType   The type of messages to match and so encode
 */
protected PromisingMessageToMessageEncoder(Class<? extends I> outboundMessageType) {
    matcher = TypeParameterMatcher.get(outboundMessageType);
}
 

/**
 * Create a handler publisher.
 *
 * The supplied executor must be the same event loop as the event loop that this handler is eventually registered
 * with, if not, an exception will be thrown when the handler is registered.
 *
 * @param executor The executor to execute asynchronous events from the subscriber on.
 * @param subscriberMessageType The type of message this publisher accepts.
 */
public HandlerPublisher(EventExecutor executor, Class<? extends T> subscriberMessageType) {
    this.executor = executor;
    this.matcher = TypeParameterMatcher.get(subscriberMessageType);
}
 

/**
 * Create a new instance.
 *
 * @param inboundMessageType    The type of messages to decode
 * @param outboundMessageType   The type of messages to encode
 */
protected MessageToMessageCodec(
        Class<? extends INBOUND_IN> inboundMessageType, Class<? extends OUTBOUND_IN> outboundMessageType) {
    inboundMsgMatcher = TypeParameterMatcher.get(inboundMessageType);
    outboundMsgMatcher = TypeParameterMatcher.get(outboundMessageType);
}
 

/**
 * Create a new instance
 *
 * @param outboundMessageType   The type of messages to match
 * @param preferDirect          {@code true} if a direct {@link ByteBuf} should be tried to be used as target for
 *                              the encoded messages. If {@code false} is used it will allocate a heap
 *                              {@link ByteBuf}, which is backed by an byte array.
 */
protected MessageToByteEncoder(Class<? extends I> outboundMessageType, boolean preferDirect) {
    matcher = TypeParameterMatcher.get(outboundMessageType);
    this.preferDirect = preferDirect;
}
 

/**
 * Create a new instance
 *
 * @param inboundMessageType    The type of messages to match and so decode
 */
protected MessageToMessageDecoder(Class<? extends I> inboundMessageType) {
    matcher = TypeParameterMatcher.get(inboundMessageType);
}
 

/**
 * Create a new instance
 *
 * @param outboundMessageType   The type of messages to match and so encode
 */
protected MessageToMessageEncoder(Class<? extends I> outboundMessageType) {
    matcher = TypeParameterMatcher.get(outboundMessageType);
}
 

/**
 * Create a new instance
 *
 * @param outboundMessageType   The type of messages to match
 * @param preferDirect          {@code true} if a direct {@link ByteBuf} should be tried to be used as target for
 *                              the encoded messages. If {@code false} is used it will allocate a heap
 *                              {@link ByteBuf}, which is backed by an byte array.
 */
protected ByteToMessageCodec(Class<? extends I> outboundMessageType, boolean preferDirect) {
    ensureNotSharable();
    outboundMsgMatcher = TypeParameterMatcher.get(outboundMessageType);
    encoder = new Encoder(preferDirect);
}
 

/**
 * @param executor the {@link EventExecutor} which is used to notify the listeners of the {@link Future} returned
 *                 by {@link #resolve(SocketAddress)}
 * @param addressType the type of the {@link SocketAddress} supported by this resolver
 */
protected AbstractAddressResolver(EventExecutor executor, Class<? extends T> addressType) {
    this.executor = checkNotNull(executor, "executor");
    matcher = TypeParameterMatcher.get(addressType);
}