1 /* 2 * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"). 5 * You may not use this file except in compliance with the License. 6 * A copy of the License is located at 7 * 8 * http://aws.amazon.com/apache2.0 9 * 10 * or in the "license" file accompanying this file. This file is distributed 11 * on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either 12 * express or implied. See the License for the specific language governing 13 * permissions and limitations under the License. 14 */ 15 16 package software.amazon.awssdk.http.nio.netty.internal.utils; 17 18 import io.netty.buffer.ByteBufAllocator; 19 import io.netty.channel.Channel; 20 import io.netty.channel.ChannelFuture; 21 import io.netty.channel.ChannelHandler; 22 import io.netty.channel.ChannelHandlerContext; 23 import io.netty.channel.ChannelPipeline; 24 import io.netty.channel.ChannelProgressivePromise; 25 import io.netty.channel.ChannelPromise; 26 import io.netty.util.Attribute; 27 import io.netty.util.AttributeKey; 28 import io.netty.util.concurrent.EventExecutor; 29 import java.net.SocketAddress; 30 import software.amazon.awssdk.annotations.SdkInternalApi; 31 32 /** 33 * An abstract implementation of {@link ChannelHandlerContext} that delegates to another 34 * context for non-overridden methods. 35 */ 36 @SdkInternalApi 37 public abstract class DelegatingChannelHandlerContext implements ChannelHandlerContext { 38 private final ChannelHandlerContext delegate; 39 DelegatingChannelHandlerContext(ChannelHandlerContext delegate)40 public DelegatingChannelHandlerContext(ChannelHandlerContext delegate) { 41 this.delegate = delegate; 42 } 43 44 @Override channel()45 public Channel channel() { 46 return delegate.channel(); 47 } 48 49 @Override executor()50 public EventExecutor executor() { 51 return delegate.executor(); 52 } 53 54 @Override name()55 public String name() { 56 return delegate.name(); 57 } 58 59 @Override handler()60 public ChannelHandler handler() { 61 return delegate.handler(); 62 } 63 64 @Override isRemoved()65 public boolean isRemoved() { 66 return delegate.isRemoved(); 67 } 68 69 @Override fireChannelRegistered()70 public ChannelHandlerContext fireChannelRegistered() { 71 return delegate.fireChannelRegistered(); 72 } 73 74 @Override fireChannelUnregistered()75 public ChannelHandlerContext fireChannelUnregistered() { 76 return delegate.fireChannelUnregistered(); 77 } 78 79 @Override fireChannelActive()80 public ChannelHandlerContext fireChannelActive() { 81 return delegate.fireChannelActive(); 82 } 83 84 @Override fireChannelInactive()85 public ChannelHandlerContext fireChannelInactive() { 86 return delegate.fireChannelInactive(); 87 } 88 89 @Override fireExceptionCaught(Throwable cause)90 public ChannelHandlerContext fireExceptionCaught(Throwable cause) { 91 return delegate.fireExceptionCaught(cause); 92 } 93 94 @Override fireUserEventTriggered(Object evt)95 public ChannelHandlerContext fireUserEventTriggered(Object evt) { 96 return delegate.fireUserEventTriggered(evt); 97 } 98 99 @Override fireChannelRead(Object msg)100 public ChannelHandlerContext fireChannelRead(Object msg) { 101 return delegate.fireChannelRead(msg); 102 } 103 104 @Override fireChannelReadComplete()105 public ChannelHandlerContext fireChannelReadComplete() { 106 return delegate.fireChannelReadComplete(); 107 } 108 109 @Override fireChannelWritabilityChanged()110 public ChannelHandlerContext fireChannelWritabilityChanged() { 111 return delegate.fireChannelWritabilityChanged(); 112 } 113 114 @Override bind(SocketAddress localAddress)115 public ChannelFuture bind(SocketAddress localAddress) { 116 return delegate.bind(localAddress); 117 } 118 119 @Override connect(SocketAddress remoteAddress)120 public ChannelFuture connect(SocketAddress remoteAddress) { 121 return delegate.connect(remoteAddress); 122 } 123 124 @Override connect(SocketAddress remoteAddress, SocketAddress localAddress)125 public ChannelFuture connect(SocketAddress remoteAddress, SocketAddress localAddress) { 126 return delegate.connect(remoteAddress, localAddress); 127 } 128 129 @Override disconnect()130 public ChannelFuture disconnect() { 131 return delegate.disconnect(); 132 } 133 134 @Override close()135 public ChannelFuture close() { 136 return delegate.close(); 137 } 138 139 @Override deregister()140 public ChannelFuture deregister() { 141 return delegate.deregister(); 142 } 143 144 @Override bind(SocketAddress localAddress, ChannelPromise promise)145 public ChannelFuture bind(SocketAddress localAddress, ChannelPromise promise) { 146 return delegate.bind(localAddress, promise); 147 } 148 149 @Override connect(SocketAddress remoteAddress, ChannelPromise promise)150 public ChannelFuture connect(SocketAddress remoteAddress, ChannelPromise promise) { 151 return delegate.connect(remoteAddress, promise); 152 } 153 154 @Override connect(SocketAddress remoteAddress, SocketAddress localAddress, ChannelPromise promise)155 public ChannelFuture connect(SocketAddress remoteAddress, SocketAddress localAddress, ChannelPromise promise) { 156 return delegate.connect(remoteAddress, localAddress, promise); 157 } 158 159 @Override disconnect(ChannelPromise promise)160 public ChannelFuture disconnect(ChannelPromise promise) { 161 return delegate.disconnect(promise); 162 } 163 164 @Override close(ChannelPromise promise)165 public ChannelFuture close(ChannelPromise promise) { 166 return delegate.close(promise); 167 } 168 169 @Override deregister(ChannelPromise promise)170 public ChannelFuture deregister(ChannelPromise promise) { 171 return delegate.deregister(promise); 172 } 173 174 @Override read()175 public ChannelHandlerContext read() { 176 return delegate.read(); 177 } 178 179 @Override write(Object msg)180 public ChannelFuture write(Object msg) { 181 return delegate.write(msg); 182 } 183 184 @Override write(Object msg, ChannelPromise promise)185 public ChannelFuture write(Object msg, ChannelPromise promise) { 186 return delegate.write(msg, promise); 187 } 188 189 @Override flush()190 public ChannelHandlerContext flush() { 191 return delegate.flush(); 192 } 193 194 @Override writeAndFlush(Object msg, ChannelPromise promise)195 public ChannelFuture writeAndFlush(Object msg, ChannelPromise promise) { 196 return delegate.writeAndFlush(msg, promise); 197 } 198 199 @Override writeAndFlush(Object msg)200 public ChannelFuture writeAndFlush(Object msg) { 201 return delegate.writeAndFlush(msg); 202 } 203 204 @Override newPromise()205 public ChannelPromise newPromise() { 206 return delegate.newPromise(); 207 } 208 209 @Override newProgressivePromise()210 public ChannelProgressivePromise newProgressivePromise() { 211 return delegate.newProgressivePromise(); 212 } 213 214 @Override newSucceededFuture()215 public ChannelFuture newSucceededFuture() { 216 return delegate.newSucceededFuture(); 217 } 218 219 @Override newFailedFuture(Throwable cause)220 public ChannelFuture newFailedFuture(Throwable cause) { 221 return delegate.newFailedFuture(cause); 222 } 223 224 @Override voidPromise()225 public ChannelPromise voidPromise() { 226 return delegate.voidPromise(); 227 } 228 229 @Override pipeline()230 public ChannelPipeline pipeline() { 231 return delegate.pipeline(); 232 } 233 234 @Override alloc()235 public ByteBufAllocator alloc() { 236 return delegate.alloc(); 237 } 238 239 @Override attr(AttributeKey<T> key)240 public <T> Attribute<T> attr(AttributeKey<T> key) { 241 return delegate.attr(key); 242 } 243 244 @Override hasAttr(AttributeKey<T> key)245 public <T> boolean hasAttr(AttributeKey<T> key) { 246 return delegate.hasAttr(key); 247 } 248 } 249