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

/**
 * @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() {
	inboundMsgMatcher = TypeParameterMatcher.find(this, MessageToMessageCodec.class, "INBOUND_IN");
	outboundMsgMatcher = TypeParameterMatcher.find(this, MessageToMessageCodec.class, "OUTBOUND_IN");
}
 

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

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

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

/**
 * 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 match out of the type parameter of the class.
 */
protected MessageToMessageEncoder() {
    matcher = TypeParameterMatcher.find(this, MessageToMessageEncoder.class, "I");
}
 

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");
}
 

/**
 * 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 match out of the type parameter of the class.
 *
 * @param autoRelease   {@code true} if handled messages should be released automatically by pass them to
 *                      {@link ReferenceCountUtil#release(Object)}.
 */
protected SimpleChannelInboundHandler(boolean autoRelease) {
    matcher = TypeParameterMatcher.find(this, SimpleChannelInboundHandler.class, "I");
    this.autoRelease = autoRelease;
}
 

/**
 * 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) {
    CodecUtil.ensureNotSharable(this);
    outboundMsgMatcher = TypeParameterMatcher.find(this, ByteToMessageCodec.class, "I");
    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.创建一个新的实例，该实例将尝试检测与类的类型参数匹配的类型。
 *
 * @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 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 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.创建一个新的实例，该实例将尝试检测与类的类型参数匹配的类型。
 *
 * @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 which will try to detect the types to match out of the type parameter of the class.创建一个新的实例，该实例将尝试检测类的类型参数匹配的类型。
 *
 * @param autoRelease   {@code true} if handled messages should be released automatically by passing them to
 *                      {@link ReferenceCountUtil#release(Object)}.
 */
protected SimpleChannelInboundHandler(boolean autoRelease) {
    matcher = TypeParameterMatcher.find(this, SimpleChannelInboundHandler.class, "I");
    this.autoRelease = autoRelease;
}