io.netty.util.internal.TypeParameterMatcher Java Examples

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

/**
 * Create a new instance which will try to detect the types to match out of the type parameter of the class.
 */
protected MessageToMessageEncoder() {
    matcher = TypeParameterMatcher.find(this, MessageToMessageEncoder.class, "I");
}
 

/**
 * Create a new instance which will try to detect the types to match out of the type parameter of the class.
 */
protected MessageToMessageDecoder() {
    matcher = TypeParameterMatcher.find(this, MessageToMessageDecoder.class, "I");
}
 

/**
 * Create a new instance which will try to detect the types to decode and encode out of the type parameter
 * of the class.
 */
protected MessageToMessageCodec() {
    inboundMsgMatcher = TypeParameterMatcher.find(this, MessageToMessageCodec.class, "INBOUND_IN");
    outboundMsgMatcher = TypeParameterMatcher.find(this, MessageToMessageCodec.class, "OUTBOUND_IN");
}
 

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

protected AbstractChannelHandler(boolean autoRelease) {
    matcherInbound = TypeParameterMatcher.find(this, AbstractChannelHandler.class, "I");
    matcherOutbound = TypeParameterMatcher.find(this, AbstractChannelHandler.class, "O");
    this.autoRelease = autoRelease;
}
 

/**
 * Create a new instance which will try to detect the types to decode and encode out of the type parameter
 * of the class.创建一个新的实例，该实例将尝试检测用于解码和编码类的类型参数的类型。
 */
protected MessageToMessageCodec() {
    inboundMsgMatcher = TypeParameterMatcher.find(this, MessageToMessageCodec.class, "INBOUND_IN");
    outboundMsgMatcher = TypeParameterMatcher.find(this, MessageToMessageCodec.class, "OUTBOUND_IN");
}
 

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

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

/**
 * Create a new instance which will try to detect the types to match out of the type parameter of the class.创建一个新的实例，该实例将尝试检测与类的类型参数匹配的类型。
 */
protected MessageToMessageDecoder() {
    matcher = TypeParameterMatcher.find(this, MessageToMessageDecoder.class, "I");
}
 

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

/**
 * Creates a new {@link Client}.
 *
 * @param channel The underlying channel.
 */
Client(Channel channel) {
    this.channel = channel;
    ipAddress = NetworkUtils.getIpAddress(channel);
    parameterMatcher = TypeParameterMatcher.find(this, Client.class, "I");
}
 

protected MessageToMessageEncoder() {
	this.matcher = TypeParameterMatcher.find(this, MessageToMessageEncoder.class, "I");
}
 

protected MessageToMessageEncoder(final Class<? extends I> clazz) {
	this.matcher = TypeParameterMatcher.get(clazz);
}
 

protected MessageToMessageCodec() {
	inboundMsgMatcher = TypeParameterMatcher.find(this, MessageToMessageCodec.class, "INBOUND_IN");
	outboundMsgMatcher = TypeParameterMatcher.find(this, MessageToMessageCodec.class, "OUTBOUND_IN");
}
 

/**
 * @param executor the {@link EventExecutor} which is used to notify the listeners of the {@link Future} returned
 *                 by {@link #resolve(SocketAddress)}
 */
protected AbstractAddressResolver(EventExecutor executor) {
    this.executor = checkNotNull(executor, "executor");
    matcher = TypeParameterMatcher.find(this, AbstractAddressResolver.class, "T");
}
 

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
 * @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 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 tpye 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 which will try to detect the types to match out of the type parameter of the class.
 *
 * @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(boolean preferDirect) {
    matcher = TypeParameterMatcher.find(this, MessageToByteEncoder.class, "I");
    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 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
 * @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;
}
 

/**
 * @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);
}
 

/**
 * Create a new instance which will try to detect the types to match out of the type parameter of the class.创建一个新的实例，该实例将尝试检测与类的类型参数匹配的类型。
 *
 * @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(boolean preferDirect) {
    ensureNotSharable();
    outboundMsgMatcher = TypeParameterMatcher.find(this, ByteToMessageCodec.class, "I");
    encoder = new Encoder(preferDirect);
}
 

/**
 * 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);
}
 

/**
 * Create a new instance which will try to detect the types to match out of the type parameter of the class.
 * 创建一个新的实例，该实例将尝试检测类的类型参数匹配的类型。
 */
protected MessageToMessageEncoder() {
    matcher = TypeParameterMatcher.find(this, MessageToMessageEncoder.class, "I");
}
 

/**
 * 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);
}