NEED_MORE_INPUT poison.\n- * @see #NEED_MORE_INPUT\n- */\n- @Adaptive({Constants.CODEC_KEY})\n- Object decode(Channel channel, InputStream input) throws IOException;\n-\n-}\n+/*\r\n+ * Licensed to the Apache Software Foundation (ASF) under one or more\r\n+ * contributor license agreements. See the NOTICE file distributed with\r\n+ * this work for additional information regarding copyright ownership.\r\n+ * The ASF licenses this file to You under the Apache License, Version 2.0\r\n+ * (the \"License\"); you may not use this file except in compliance with\r\n+ * the License. You may obtain a copy of the License at\r\n+ *\r\n+ * http://www.apache.org/licenses/LICENSE-2.0\r\n+ *\r\n+ * Unless required by applicable law or agreed to in writing, software\r\n+ * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n+ * See the License for the specific language governing permissions and\r\n+ * limitations under the License.\r\n+ */\r\n+package org.apache.dubbo.remoting;\r\n+\r\n+import org.apache.dubbo.common.extension.Adaptive;\r\n+import org.apache.dubbo.common.extension.SPI;\r\n+\r\n+import java.io.IOException;\r\n+import java.io.InputStream;\r\n+import java.io.OutputStream;\r\n+\r\n+/**\r\n+ * Codec. (SPI, Singleton, ThreadSafe)\r\n+ */\r\n+@Deprecated\r\n+@SPI\r\n+public interface Codec {\r\n+\r\n+ /**\r\n+ * Need more input poison.\r\n+ *\r\n+ * @see #decode(Channel, InputStream)\r\n+ */\r\n+ Object NEED_MORE_INPUT = new Object();\r\n+\r\n+ /**\r\n+ * Encode message.\r\n+ *\r\n+ * @param channel channel.\r\n+ * @param output output stream.\r\n+ * @param message message.\r\n+ */\r\n+ @Adaptive({Constants.CODEC_KEY})\r\n+ void encode(Channel channel, OutputStream output, Object message) throws IOException;\r\n+\r\n+ /**\r\n+ * Decode message.\r\n+ *\r\n+ * @param channel channel.\r\n+ * @param input input stream.\r\n+ * @return message or NEED_MORE_INPUT poison.\r\n+ * @see #NEED_MORE_INPUT\r\n+ */\r\n+ @Adaptive({Constants.CODEC_KEY})\r\n+ Object decode(Channel channel, InputStream input) throws IOException;\r\n+\r\n+}\r\n"}, {"source1": "org/apache/dubbo/remoting/Codec2.java", "source2": "org/apache/dubbo/remoting/Codec2.java", "comments": ["Ordering differences only"], "unified_diff": "@@ -1,40 +1,40 @@\n-/*\n- * Licensed to the Apache Software Foundation (ASF) under one or more\n- * contributor license agreements. See the NOTICE file distributed with\n- * this work for additional information regarding copyright ownership.\n- * The ASF licenses this file to You under the Apache License, Version 2.0\n- * (the \"License\"); you may not use this file except in compliance with\n- * the License. You may obtain a copy of the License at\n- *\n- * http://www.apache.org/licenses/LICENSE-2.0\n- *\n- * Unless required by applicable law or agreed to in writing, software\n- * distributed under the License is distributed on an \"AS IS\" BASIS,\n- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n- * See the License for the specific language governing permissions and\n- * limitations under the License.\n- */\n-package org.apache.dubbo.remoting;\n-\n-import org.apache.dubbo.common.extension.Adaptive;\n-import org.apache.dubbo.common.extension.SPI;\n-import org.apache.dubbo.remoting.buffer.ChannelBuffer;\n-\n-import java.io.IOException;\n-\n-@SPI\n-public interface Codec2 {\n-\n- @Adaptive({Constants.CODEC_KEY})\n- void encode(Channel channel, ChannelBuffer buffer, Object message) throws IOException;\n-\n- @Adaptive({Constants.CODEC_KEY})\n- Object decode(Channel channel, ChannelBuffer buffer) throws IOException;\n-\n-\n- enum DecodeResult {\n- NEED_MORE_INPUT, SKIP_SOME_INPUT\n- }\n-\n-}\n-\n+/*\r\n+ * Licensed to the Apache Software Foundation (ASF) under one or more\r\n+ * contributor license agreements. See the NOTICE file distributed with\r\n+ * this work for additional information regarding copyright ownership.\r\n+ * The ASF licenses this file to You under the Apache License, Version 2.0\r\n+ * (the \"License\"); you may not use this file except in compliance with\r\n+ * the License. You may obtain a copy of the License at\r\n+ *\r\n+ * http://www.apache.org/licenses/LICENSE-2.0\r\n+ *\r\n+ * Unless required by applicable law or agreed to in writing, software\r\n+ * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n+ * See the License for the specific language governing permissions and\r\n+ * limitations under the License.\r\n+ */\r\n+package org.apache.dubbo.remoting;\r\n+\r\n+import org.apache.dubbo.common.extension.Adaptive;\r\n+import org.apache.dubbo.common.extension.SPI;\r\n+import org.apache.dubbo.remoting.buffer.ChannelBuffer;\r\n+\r\n+import java.io.IOException;\r\n+\r\n+@SPI\r\n+public interface Codec2 {\r\n+\r\n+ @Adaptive({Constants.CODEC_KEY})\r\n+ void encode(Channel channel, ChannelBuffer buffer, Object message) throws IOException;\r\n+\r\n+ @Adaptive({Constants.CODEC_KEY})\r\n+ Object decode(Channel channel, ChannelBuffer buffer) throws IOException;\r\n+\r\n+\r\n+ enum DecodeResult {\r\n+ NEED_MORE_INPUT, SKIP_SOME_INPUT\r\n+ }\r\n+\r\n+}\r\n+\r\n"}, {"source1": "org/apache/dubbo/remoting/Constants.java", "source2": "org/apache/dubbo/remoting/Constants.java", "comments": ["Ordering differences only"], "unified_diff": "@@ -1,138 +1,138 @@\n-/*\n- * Licensed to the Apache Software Foundation (ASF) under one or more\n- * contributor license agreements. See the NOTICE file distributed with\n- * this work for additional information regarding copyright ownership.\n- * The ASF licenses this file to You under the Apache License, Version 2.0\n- * (the \"License\"); you may not use this file except in compliance with\n- * the License. You may obtain a copy of the License at\n- *\n- * http://www.apache.org/licenses/LICENSE-2.0\n- *\n- * Unless required by applicable law or agreed to in writing, software\n- * distributed under the License is distributed on an \"AS IS\" BASIS,\n- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n- * See the License for the specific language governing permissions and\n- * limitations under the License.\n- */\n-\n-package org.apache.dubbo.remoting;\n-\n-\n-public interface Constants {\n-\n- String BUFFER_KEY = \"buffer\";\n-\n- /**\n- * default buffer size is 8k.\n- */\n- int DEFAULT_BUFFER_SIZE = 8 * 1024;\n-\n- int MAX_BUFFER_SIZE = 16 * 1024;\n-\n- int MIN_BUFFER_SIZE = 1 * 1024;\n-\n- String IDLE_TIMEOUT_KEY = \"idle.timeout\";\n-\n- int DEFAULT_IDLE_TIMEOUT = 600 * 1000;\n- /**\n- * max size of channel. default value is zero that means unlimited.\n- */\n- String ACCEPTS_KEY = \"accepts\";\n-\n- int DEFAULT_ACCEPTS = 0;\n-\n- String CONNECT_QUEUE_CAPACITY = \"connect.queue.capacity\";\n-\n- String CONNECT_QUEUE_WARNING_SIZE = \"connect.queue.warning.size\";\n-\n- int DEFAULT_CONNECT_QUEUE_WARNING_SIZE = 1000;\n-\n- String CHARSET_KEY = \"charset\";\n-\n- String DEFAULT_CHARSET = \"UTF-8\";\n-\n- /**\n- * Every heartbeat duration / HEARTBEAT_CHECK_TICK, check if a heartbeat should be sent. Every heartbeat timeout\n- * duration / HEARTBEAT_CHECK_TICK, check if a connection should be closed on server side, and if reconnect on\n- * client side\n- */\n- int HEARTBEAT_CHECK_TICK = 3;\n-\n- /**\n- * the least heartbeat during is 1000 ms.\n- */\n- long LEAST_HEARTBEAT_DURATION = 1000;\n-\n- /**\n- * ticks per wheel.\n- */\n- int TICKS_PER_WHEEL = 128;\n- String PAYLOAD_KEY = \"payload\";\n- /**\n- * 8M\n- */\n- int DEFAULT_PAYLOAD = 8 * 1024 * 1024;\n-\n- String CONNECT_TIMEOUT_KEY = \"connect.timeout\";\n-\n- int DEFAULT_CONNECT_TIMEOUT = 3000;\n-\n- String SERIALIZATION_KEY = \"serialization\";\n-\n- String DEFAULT_REMOTING_SERIALIZATION = \"hessian2\";\n-\n- String CODEC_KEY = \"codec\";\n-\n- String CODEC_VERSION_KEY = \"codec.version\";\n-\n- String SERVER_KEY = \"server\";\n-\n- String CLIENT_KEY = \"client\";\n-\n- String DEFAULT_REMOTING_CLIENT = \"netty\";\n-\n- String TRANSPORTER_KEY = \"transporter\";\n-\n- String DEFAULT_TRANSPORTER = \"netty\";\n-\n- String EXCHANGER_KEY = \"exchanger\";\n-\n- String DEFAULT_EXCHANGER = \"header\";\n-\n- String DISPACTHER_KEY = \"dispacther\";\n-\n- int DEFAULT_IO_THREADS = Math.min(Runtime.getRuntime().availableProcessors() + 1, 32);\n-\n- String BIND_IP_KEY = \"bind.ip\";\n-\n- String BIND_PORT_KEY = \"bind.port\";\n-\n- String SENT_KEY = \"sent\";\n-\n- String DISPATCHER_KEY = \"dispatcher\";\n-\n- String CHANNEL_ATTRIBUTE_READONLY_KEY = \"channel.readonly\";\n-\n- String CHANNEL_READONLYEVENT_SENT_KEY = \"channel.readonly.sent\";\n-\n- String CHANNEL_SEND_READONLYEVENT_KEY = \"channel.readonly.send\";\n-\n- String RECONNECT_KEY = \"reconnect\";\n-\n- int DEFAULT_RECONNECT_PERIOD = 2000;\n-\n- String SEND_RECONNECT_KEY = \"send.reconnect\";\n-\n- String CHECK_KEY = \"check\";\n-\n- String PROMPT_KEY = \"prompt\";\n-\n- String DEFAULT_PROMPT = \"dubbo>\";\n- String TELNET = \"telnet\";\n- String HEARTBEAT_KEY = \"heartbeat\";\n- int DEFAULT_HEARTBEAT = 60 * 1000;\n- String HEARTBEAT_TIMEOUT_KEY = \"heartbeat.timeout\";\n- String CONNECTIONS_KEY = \"connections\";\n-\n- int DEFAULT_BACKLOG = 1024;\n+/*\r\n+ * Licensed to the Apache Software Foundation (ASF) under one or more\r\n+ * contributor license agreements. See the NOTICE file distributed with\r\n+ * this work for additional information regarding copyright ownership.\r\n+ * The ASF licenses this file to You under the Apache License, Version 2.0\r\n+ * (the \"License\"); you may not use this file except in compliance with\r\n+ * the License. You may obtain a copy of the License at\r\n+ *\r\n+ * http://www.apache.org/licenses/LICENSE-2.0\r\n+ *\r\n+ * Unless required by applicable law or agreed to in writing, software\r\n+ * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n+ * See the License for the specific language governing permissions and\r\n+ * limitations under the License.\r\n+ */\r\n+\r\n+package org.apache.dubbo.remoting;\r\n+\r\n+\r\n+public interface Constants {\r\n+\r\n+ String BUFFER_KEY = \"buffer\";\r\n+\r\n+ /**\r\n+ * default buffer size is 8k.\r\n+ */\r\n+ int DEFAULT_BUFFER_SIZE = 8 * 1024;\r\n+\r\n+ int MAX_BUFFER_SIZE = 16 * 1024;\r\n+\r\n+ int MIN_BUFFER_SIZE = 1 * 1024;\r\n+\r\n+ String IDLE_TIMEOUT_KEY = \"idle.timeout\";\r\n+\r\n+ int DEFAULT_IDLE_TIMEOUT = 600 * 1000;\r\n+ /**\r\n+ * max size of channel. default value is zero that means unlimited.\r\n+ */\r\n+ String ACCEPTS_KEY = \"accepts\";\r\n+\r\n+ int DEFAULT_ACCEPTS = 0;\r\n+\r\n+ String CONNECT_QUEUE_CAPACITY = \"connect.queue.capacity\";\r\n+\r\n+ String CONNECT_QUEUE_WARNING_SIZE = \"connect.queue.warning.size\";\r\n+\r\n+ int DEFAULT_CONNECT_QUEUE_WARNING_SIZE = 1000;\r\n+\r\n+ String CHARSET_KEY = \"charset\";\r\n+\r\n+ String DEFAULT_CHARSET = \"UTF-8\";\r\n+\r\n+ /**\r\n+ * Every heartbeat duration / HEARTBEAT_CHECK_TICK, check if a heartbeat should be sent. Every heartbeat timeout\r\n+ * duration / HEARTBEAT_CHECK_TICK, check if a connection should be closed on server side, and if reconnect on\r\n+ * client side\r\n+ */\r\n+ int HEARTBEAT_CHECK_TICK = 3;\r\n+\r\n+ /**\r\n+ * the least heartbeat during is 1000 ms.\r\n+ */\r\n+ long LEAST_HEARTBEAT_DURATION = 1000;\r\n+\r\n+ /**\r\n+ * ticks per wheel.\r\n+ */\r\n+ int TICKS_PER_WHEEL = 128;\r\n+ String PAYLOAD_KEY = \"payload\";\r\n+ /**\r\n+ * 8M\r\n+ */\r\n+ int DEFAULT_PAYLOAD = 8 * 1024 * 1024;\r\n+\r\n+ String CONNECT_TIMEOUT_KEY = \"connect.timeout\";\r\n+\r\n+ int DEFAULT_CONNECT_TIMEOUT = 3000;\r\n+\r\n+ String SERIALIZATION_KEY = \"serialization\";\r\n+\r\n+ String DEFAULT_REMOTING_SERIALIZATION = \"hessian2\";\r\n+\r\n+ String CODEC_KEY = \"codec\";\r\n+\r\n+ String CODEC_VERSION_KEY = \"codec.version\";\r\n+\r\n+ String SERVER_KEY = \"server\";\r\n+\r\n+ String CLIENT_KEY = \"client\";\r\n+\r\n+ String DEFAULT_REMOTING_CLIENT = \"netty\";\r\n+\r\n+ String TRANSPORTER_KEY = \"transporter\";\r\n+\r\n+ String DEFAULT_TRANSPORTER = \"netty\";\r\n+\r\n+ String EXCHANGER_KEY = \"exchanger\";\r\n+\r\n+ String DEFAULT_EXCHANGER = \"header\";\r\n+\r\n+ String DISPACTHER_KEY = \"dispacther\";\r\n+\r\n+ int DEFAULT_IO_THREADS = Math.min(Runtime.getRuntime().availableProcessors() + 1, 32);\r\n+\r\n+ String BIND_IP_KEY = \"bind.ip\";\r\n+\r\n+ String BIND_PORT_KEY = \"bind.port\";\r\n+\r\n+ String SENT_KEY = \"sent\";\r\n+\r\n+ String DISPATCHER_KEY = \"dispatcher\";\r\n+\r\n+ String CHANNEL_ATTRIBUTE_READONLY_KEY = \"channel.readonly\";\r\n+\r\n+ String CHANNEL_READONLYEVENT_SENT_KEY = \"channel.readonly.sent\";\r\n+\r\n+ String CHANNEL_SEND_READONLYEVENT_KEY = \"channel.readonly.send\";\r\n+\r\n+ String RECONNECT_KEY = \"reconnect\";\r\n+\r\n+ int DEFAULT_RECONNECT_PERIOD = 2000;\r\n+\r\n+ String SEND_RECONNECT_KEY = \"send.reconnect\";\r\n+\r\n+ String CHECK_KEY = \"check\";\r\n+\r\n+ String PROMPT_KEY = \"prompt\";\r\n+\r\n+ String DEFAULT_PROMPT = \"dubbo>\";\r\n+ String TELNET = \"telnet\";\r\n+ String HEARTBEAT_KEY = \"heartbeat\";\r\n+ int DEFAULT_HEARTBEAT = 60 * 1000;\r\n+ String HEARTBEAT_TIMEOUT_KEY = \"heartbeat.timeout\";\r\n+ String CONNECTIONS_KEY = \"connections\";\r\n+\r\n+ int DEFAULT_BACKLOG = 1024;\r\n }\n"}, {"source1": "org/apache/dubbo/remoting/Dispatcher.java", "source2": "org/apache/dubbo/remoting/Dispatcher.java", "comments": ["Ordering differences only"], "unified_diff": "@@ -1,41 +1,41 @@\n-/*\n- * Licensed to the Apache Software Foundation (ASF) under one or more\n- * contributor license agreements. See the NOTICE file distributed with\n- * this work for additional information regarding copyright ownership.\n- * The ASF licenses this file to You under the Apache License, Version 2.0\n- * (the \"License\"); you may not use this file except in compliance with\n- * the License. You may obtain a copy of the License at\n- *\n- * http://www.apache.org/licenses/LICENSE-2.0\n- *\n- * Unless required by applicable law or agreed to in writing, software\n- * distributed under the License is distributed on an \"AS IS\" BASIS,\n- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n- * See the License for the specific language governing permissions and\n- * limitations under the License.\n- */\n-package org.apache.dubbo.remoting;\n-\n-import org.apache.dubbo.common.URL;\n-import org.apache.dubbo.common.extension.Adaptive;\n-import org.apache.dubbo.common.extension.SPI;\n-import org.apache.dubbo.remoting.transport.dispatcher.all.AllDispatcher;\n-\n-/**\n- * ChannelHandlerWrapper (SPI, Singleton, ThreadSafe)\n- */\n-@SPI(AllDispatcher.NAME)\n-public interface Dispatcher {\n-\n- /**\n- * dispatch the message to threadpool.\n- *\n- * @param handler\n- * @param url\n- * @return channel handler\n- */\n- @Adaptive({Constants.DISPATCHER_KEY, \"dispather\", \"channel.handler\"})\n- // The last two parameters are reserved for compatibility with the old configuration\n- ChannelHandler dispatch(ChannelHandler handler, URL url);\n-\n-}\n+/*\r\n+ * Licensed to the Apache Software Foundation (ASF) under one or more\r\n+ * contributor license agreements. See the NOTICE file distributed with\r\n+ * this work for additional information regarding copyright ownership.\r\n+ * The ASF licenses this file to You under the Apache License, Version 2.0\r\n+ * (the \"License\"); you may not use this file except in compliance with\r\n+ * the License. You may obtain a copy of the License at\r\n+ *\r\n+ * http://www.apache.org/licenses/LICENSE-2.0\r\n+ *\r\n+ * Unless required by applicable law or agreed to in writing, software\r\n+ * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n+ * See the License for the specific language governing permissions and\r\n+ * limitations under the License.\r\n+ */\r\n+package org.apache.dubbo.remoting;\r\n+\r\n+import org.apache.dubbo.common.URL;\r\n+import org.apache.dubbo.common.extension.Adaptive;\r\n+import org.apache.dubbo.common.extension.SPI;\r\n+import org.apache.dubbo.remoting.transport.dispatcher.all.AllDispatcher;\r\n+\r\n+/**\r\n+ * ChannelHandlerWrapper (SPI, Singleton, ThreadSafe)\r\n+ */\r\n+@SPI(AllDispatcher.NAME)\r\n+public interface Dispatcher {\r\n+\r\n+ /**\r\n+ * dispatch the message to threadpool.\r\n+ *\r\n+ * @param handler\r\n+ * @param url\r\n+ * @return channel handler\r\n+ */\r\n+ @Adaptive({Constants.DISPATCHER_KEY, \"dispather\", \"channel.handler\"})\r\n+ // The last two parameters are reserved for compatibility with the old configuration\r\n+ ChannelHandler dispatch(ChannelHandler handler, URL url);\r\n+\r\n+}\r\n"}, {"source1": "org/apache/dubbo/remoting/IdleSensible.java", "source2": "org/apache/dubbo/remoting/IdleSensible.java", "comments": ["Ordering differences only"], "unified_diff": "@@ -1,34 +1,34 @@\n-/*\n- * Licensed to the Apache Software Foundation (ASF) under one or more\n- * contributor license agreements. See the NOTICE file distributed with\n- * this work for additional information regarding copyright ownership.\n- * The ASF licenses this file to You under the Apache License, Version 2.0\n- * (the \"License\"); you may not use this file except in compliance with\n- * the License. You may obtain a copy of the License at\n- *\n- * http://www.apache.org/licenses/LICENSE-2.0\n- *\n- * Unless required by applicable law or agreed to in writing, software\n- * distributed under the License is distributed on an \"AS IS\" BASIS,\n- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n- * See the License for the specific language governing permissions and\n- * limitations under the License.\n- */\n-package org.apache.dubbo.remoting;\n-\n-/**\n- * Indicate whether the implementation (for both server and client) has the ability to sense and handle idle connection.\n- * If the server has the ability to handle idle connection, it should close the connection when it happens, and if\n- * the client has the ability to handle idle connection, it should send the heartbeat to the server.\n- */\n-public interface IdleSensible {\n- /**\n- * Whether the implementation can sense and handle the idle connection. By default it's false, the implementation\n- * relies on dedicated timer to take care of idle connection.\n- *\n- * @return whether has the ability to handle idle connection\n- */\n- default boolean canHandleIdle() {\n- return false;\n- }\n-}\n+/*\r\n+ * Licensed to the Apache Software Foundation (ASF) under one or more\r\n+ * contributor license agreements. See the NOTICE file distributed with\r\n+ * this work for additional information regarding copyright ownership.\r\n+ * The ASF licenses this file to You under the Apache License, Version 2.0\r\n+ * (the \"License\"); you may not use this file except in compliance with\r\n+ * the License. You may obtain a copy of the License at\r\n+ *\r\n+ * http://www.apache.org/licenses/LICENSE-2.0\r\n+ *\r\n+ * Unless required by applicable law or agreed to in writing, software\r\n+ * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n+ * See the License for the specific language governing permissions and\r\n+ * limitations under the License.\r\n+ */\r\n+package org.apache.dubbo.remoting;\r\n+\r\n+/**\r\n+ * Indicate whether the implementation (for both server and client) has the ability to sense and handle idle connection.\r\n+ * If the server has the ability to handle idle connection, it should close the connection when it happens, and if\r\n+ * the client has the ability to handle idle connection, it should send the heartbeat to the server.\r\n+ */\r\n+public interface IdleSensible {\r\n+ /**\r\n+ * Whether the implementation can sense and handle the idle connection. By default it's false, the implementation\r\n+ * relies on dedicated timer to take care of idle connection.\r\n+ *\r\n+ * @return whether has the ability to handle idle connection\r\n+ */\r\n+ default boolean canHandleIdle() {\r\n+ return false;\r\n+ }\r\n+}\r\n"}, {"source1": "org/apache/dubbo/remoting/RemotingException.java", "source2": "org/apache/dubbo/remoting/RemotingException.java", "comments": ["Ordering differences only"], "unified_diff": "@@ -1,84 +1,84 @@\n-/*\n- * Licensed to the Apache Software Foundation (ASF) under one or more\n- * contributor license agreements. See the NOTICE file distributed with\n- * this work for additional information regarding copyright ownership.\n- * The ASF licenses this file to You under the Apache License, Version 2.0\n- * (the \"License\"); you may not use this file except in compliance with\n- * the License. You may obtain a copy of the License at\n- *\n- * http://www.apache.org/licenses/LICENSE-2.0\n- *\n- * Unless required by applicable law or agreed to in writing, software\n- * distributed under the License is distributed on an \"AS IS\" BASIS,\n- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n- * See the License for the specific language governing permissions and\n- * limitations under the License.\n- */\n-package org.apache.dubbo.remoting;\n-\n-import java.net.InetSocketAddress;\n-\n-/**\n- * RemotingException. (API, Prototype, ThreadSafe)\n- *\n- * @export\n- * @see org.apache.dubbo.remoting.exchange.support.DefaultFuture#get()\n- * @see org.apache.dubbo.remoting.Channel#send(Object, boolean)\n- * @see org.apache.dubbo.remoting.exchange.ExchangeChannel#request(Object)\n- * @see org.apache.dubbo.remoting.exchange.ExchangeChannel#request(Object, int)\n- * @see org.apache.dubbo.remoting.Transporter#bind(org.apache.dubbo.common.URL, ChannelHandler)\n- * @see org.apache.dubbo.remoting.Transporter#connect(org.apache.dubbo.common.URL, ChannelHandler)\n- */\n-public class RemotingException extends Exception {\n-\n- private static final long serialVersionUID = -3160452149606778709L;\n-\n- private InetSocketAddress localAddress;\n-\n- private InetSocketAddress remoteAddress;\n-\n- public RemotingException(Channel channel, String msg) {\n- this(channel == null ? null : channel.getLocalAddress(), channel == null ? null : channel.getRemoteAddress(),\n- msg);\n- }\n-\n- public RemotingException(InetSocketAddress localAddress, InetSocketAddress remoteAddress, String message) {\n- super(message);\n-\n- this.localAddress = localAddress;\n- this.remoteAddress = remoteAddress;\n- }\n-\n- public RemotingException(Channel channel, Throwable cause) {\n- this(channel == null ? null : channel.getLocalAddress(), channel == null ? null : channel.getRemoteAddress(),\n- cause);\n- }\n-\n- public RemotingException(InetSocketAddress localAddress, InetSocketAddress remoteAddress, Throwable cause) {\n- super(cause);\n-\n- this.localAddress = localAddress;\n- this.remoteAddress = remoteAddress;\n- }\n-\n- public RemotingException(Channel channel, String message, Throwable cause) {\n- this(channel == null ? null : channel.getLocalAddress(), channel == null ? null : channel.getRemoteAddress(),\n- message, cause);\n- }\n-\n- public RemotingException(InetSocketAddress localAddress, InetSocketAddress remoteAddress, String message,\n- Throwable cause) {\n- super(message, cause);\n-\n- this.localAddress = localAddress;\n- this.remoteAddress = remoteAddress;\n- }\n-\n- public InetSocketAddress getLocalAddress() {\n- return localAddress;\n- }\n-\n- public InetSocketAddress getRemoteAddress() {\n- return remoteAddress;\n- }\n+/*\r\n+ * Licensed to the Apache Software Foundation (ASF) under one or more\r\n+ * contributor license agreements. See the NOTICE file distributed with\r\n+ * this work for additional information regarding copyright ownership.\r\n+ * The ASF licenses this file to You under the Apache License, Version 2.0\r\n+ * (the \"License\"); you may not use this file except in compliance with\r\n+ * the License. You may obtain a copy of the License at\r\n+ *\r\n+ * http://www.apache.org/licenses/LICENSE-2.0\r\n+ *\r\n+ * Unless required by applicable law or agreed to in writing, software\r\n+ * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n+ * See the License for the specific language governing permissions and\r\n+ * limitations under the License.\r\n+ */\r\n+package org.apache.dubbo.remoting;\r\n+\r\n+import java.net.InetSocketAddress;\r\n+\r\n+/**\r\n+ * RemotingException. (API, Prototype, ThreadSafe)\r\n+ *\r\n+ * @export\r\n+ * @see org.apache.dubbo.remoting.exchange.support.DefaultFuture#get()\r\n+ * @see org.apache.dubbo.remoting.Channel#send(Object, boolean)\r\n+ * @see org.apache.dubbo.remoting.exchange.ExchangeChannel#request(Object)\r\n+ * @see org.apache.dubbo.remoting.exchange.ExchangeChannel#request(Object, int)\r\n+ * @see org.apache.dubbo.remoting.Transporter#bind(org.apache.dubbo.common.URL, ChannelHandler)\r\n+ * @see org.apache.dubbo.remoting.Transporter#connect(org.apache.dubbo.common.URL, ChannelHandler)\r\n+ */\r\n+public class RemotingException extends Exception {\r\n+\r\n+ private static final long serialVersionUID = -3160452149606778709L;\r\n+\r\n+ private InetSocketAddress localAddress;\r\n+\r\n+ private InetSocketAddress remoteAddress;\r\n+\r\n+ public RemotingException(Channel channel, String msg) {\r\n+ this(channel == null ? null : channel.getLocalAddress(), channel == null ? null : channel.getRemoteAddress(),\r\n+ msg);\r\n+ }\r\n+\r\n+ public RemotingException(InetSocketAddress localAddress, InetSocketAddress remoteAddress, String message) {\r\n+ super(message);\r\n+\r\n+ this.localAddress = localAddress;\r\n+ this.remoteAddress = remoteAddress;\r\n+ }\r\n+\r\n+ public RemotingException(Channel channel, Throwable cause) {\r\n+ this(channel == null ? null : channel.getLocalAddress(), channel == null ? null : channel.getRemoteAddress(),\r\n+ cause);\r\n+ }\r\n+\r\n+ public RemotingException(InetSocketAddress localAddress, InetSocketAddress remoteAddress, Throwable cause) {\r\n+ super(cause);\r\n+\r\n+ this.localAddress = localAddress;\r\n+ this.remoteAddress = remoteAddress;\r\n+ }\r\n+\r\n+ public RemotingException(Channel channel, String message, Throwable cause) {\r\n+ this(channel == null ? null : channel.getLocalAddress(), channel == null ? null : channel.getRemoteAddress(),\r\n+ message, cause);\r\n+ }\r\n+\r\n+ public RemotingException(InetSocketAddress localAddress, InetSocketAddress remoteAddress, String message,\r\n+ Throwable cause) {\r\n+ super(message, cause);\r\n+\r\n+ this.localAddress = localAddress;\r\n+ this.remoteAddress = remoteAddress;\r\n+ }\r\n+\r\n+ public InetSocketAddress getLocalAddress() {\r\n+ return localAddress;\r\n+ }\r\n+\r\n+ public InetSocketAddress getRemoteAddress() {\r\n+ return remoteAddress;\r\n+ }\r\n }\n"}, {"source1": "org/apache/dubbo/remoting/RemotingServer.java", "source2": "org/apache/dubbo/remoting/RemotingServer.java", "comments": ["Ordering differences only"], "unified_diff": "@@ -1,58 +1,58 @@\n-/*\n- * Licensed to the Apache Software Foundation (ASF) under one or more\n- * contributor license agreements. See the NOTICE file distributed with\n- * this work for additional information regarding copyright ownership.\n- * The ASF licenses this file to You under the Apache License, Version 2.0\n- * (the \"License\"); you may not use this file except in compliance with\n- * the License. You may obtain a copy of the License at\n- *\n- * http://www.apache.org/licenses/LICENSE-2.0\n- *\n- * Unless required by applicable law or agreed to in writing, software\n- * distributed under the License is distributed on an \"AS IS\" BASIS,\n- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n- * See the License for the specific language governing permissions and\n- * limitations under the License.\n- */\n-package org.apache.dubbo.remoting;\n-\n-import org.apache.dubbo.common.Resetable;\n-\n-import java.net.InetSocketAddress;\n-import java.util.Collection;\n-\n-/**\n- * Remoting Server. (API/SPI, Prototype, ThreadSafe)\n- * \n- * Client/Server\n- *\n- * @see org.apache.dubbo.remoting.Transporter#bind(org.apache.dubbo.common.URL, ChannelHandler)\n- */\n-public interface RemotingServer extends Endpoint, Resetable, IdleSensible {\n-\n- /**\n- * is bound.\n- *\n- * @return bound\n- */\n- boolean isBound();\n-\n- /**\n- * get channels.\n- *\n- * @return channels\n- */\n- Collection \r\n+ * Client/Server\r\n+ *\r\n+ * @see org.apache.dubbo.remoting.Transporter#bind(org.apache.dubbo.common.URL, ChannelHandler)\r\n+ */\r\n+public interface RemotingServer extends Endpoint, Resetable, IdleSensible {\r\n+\r\n+ /**\r\n+ * is bound.\r\n+ *\r\n+ * @return bound\r\n+ */\r\n+ boolean isBound();\r\n+\r\n+ /**\r\n+ * get channels.\r\n+ *\r\n+ * @return channels\r\n+ */\r\n+ Collection \n- * Transport Layer\n- * Client/Server\n- *\n- * @see org.apache.dubbo.remoting.Transporters\n- */\n-@SPI(\"netty\")\n-public interface Transporter {\n-\n- /**\n- * Bind a server.\n- *\n- * @param url server url\n- * @param handler\n- * @return server\n- * @throws RemotingException\n- * @see org.apache.dubbo.remoting.Transporters#bind(URL, ChannelHandler...)\n- */\n- @Adaptive({Constants.SERVER_KEY, Constants.TRANSPORTER_KEY})\n- RemotingServer bind(URL url, ChannelHandler handler) throws RemotingException;\n-\n- /**\n- * Connect to a server.\n- *\n- * @param url server url\n- * @param handler\n- * @return client\n- * @throws RemotingException\n- * @see org.apache.dubbo.remoting.Transporters#connect(URL, ChannelHandler...)\n- */\n- @Adaptive({Constants.CLIENT_KEY, Constants.TRANSPORTER_KEY})\n- Client connect(URL url, ChannelHandler handler) throws RemotingException;\n-\n-}\n+/*\r\n+ * Licensed to the Apache Software Foundation (ASF) under one or more\r\n+ * contributor license agreements. See the NOTICE file distributed with\r\n+ * this work for additional information regarding copyright ownership.\r\n+ * The ASF licenses this file to You under the Apache License, Version 2.0\r\n+ * (the \"License\"); you may not use this file except in compliance with\r\n+ * the License. You may obtain a copy of the License at\r\n+ *\r\n+ * http://www.apache.org/licenses/LICENSE-2.0\r\n+ *\r\n+ * Unless required by applicable law or agreed to in writing, software\r\n+ * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n+ * See the License for the specific language governing permissions and\r\n+ * limitations under the License.\r\n+ */\r\n+package org.apache.dubbo.remoting;\r\n+\r\n+import org.apache.dubbo.common.URL;\r\n+import org.apache.dubbo.common.extension.Adaptive;\r\n+import org.apache.dubbo.common.extension.SPI;\r\n+\r\n+/**\r\n+ * Transporter. (SPI, Singleton, ThreadSafe)\r\n+ * \r\n+ * Transport Layer\r\n+ * Client/Server\r\n+ *\r\n+ * @see org.apache.dubbo.remoting.Transporters\r\n+ */\r\n+@SPI(\"netty\")\r\n+public interface Transporter {\r\n+\r\n+ /**\r\n+ * Bind a server.\r\n+ *\r\n+ * @param url server url\r\n+ * @param handler\r\n+ * @return server\r\n+ * @throws RemotingException\r\n+ * @see org.apache.dubbo.remoting.Transporters#bind(URL, ChannelHandler...)\r\n+ */\r\n+ @Adaptive({Constants.SERVER_KEY, Constants.TRANSPORTER_KEY})\r\n+ RemotingServer bind(URL url, ChannelHandler handler) throws RemotingException;\r\n+\r\n+ /**\r\n+ * Connect to a server.\r\n+ *\r\n+ * @param url server url\r\n+ * @param handler\r\n+ * @return client\r\n+ * @throws RemotingException\r\n+ * @see org.apache.dubbo.remoting.Transporters#connect(URL, ChannelHandler...)\r\n+ */\r\n+ @Adaptive({Constants.CLIENT_KEY, Constants.TRANSPORTER_KEY})\r\n+ Client connect(URL url, ChannelHandler handler) throws RemotingException;\r\n+\r\n+}\r\n"}, {"source1": "org/apache/dubbo/remoting/buffer/AbstractChannelBuffer.java", "source2": "org/apache/dubbo/remoting/buffer/AbstractChannelBuffer.java", "comments": ["Ordering differences only"], "unified_diff": "@@ -1,341 +1,341 @@\n-/*\n- * Licensed to the Apache Software Foundation (ASF) under one or more\n- * contributor license agreements. See the NOTICE file distributed with\n- * this work for additional information regarding copyright ownership.\n- * The ASF licenses this file to You under the Apache License, Version 2.0\n- * (the \"License\"); you may not use this file except in compliance with\n- * the License. You may obtain a copy of the License at\n- *\n- * http://www.apache.org/licenses/LICENSE-2.0\n- *\n- * Unless required by applicable law or agreed to in writing, software\n- * distributed under the License is distributed on an \"AS IS\" BASIS,\n- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n- * See the License for the specific language governing permissions and\n- * limitations under the License.\n- */\n-\n-package org.apache.dubbo.remoting.buffer;\n-\n-import java.io.IOException;\n-import java.io.InputStream;\n-import java.io.OutputStream;\n-import java.nio.ByteBuffer;\n-\n-public abstract class AbstractChannelBuffer implements ChannelBuffer {\n-\n- private int readerIndex;\n-\n- private int writerIndex;\n-\n- private int markedReaderIndex;\n-\n- private int markedWriterIndex;\n-\n- @Override\n- public int readerIndex() {\n- return readerIndex;\n- }\n-\n- @Override\n- public void readerIndex(int readerIndex) {\n- if (readerIndex < 0 || readerIndex > writerIndex) {\n- throw new IndexOutOfBoundsException();\n- }\n- this.readerIndex = readerIndex;\n- }\n-\n- @Override\n- public int writerIndex() {\n- return writerIndex;\n- }\n-\n- @Override\n- public void writerIndex(int writerIndex) {\n- if (writerIndex < readerIndex || writerIndex > capacity()) {\n- throw new IndexOutOfBoundsException();\n- }\n- this.writerIndex = writerIndex;\n- }\n-\n- @Override\n- public void setIndex(int readerIndex, int writerIndex) {\n- if (readerIndex < 0 || readerIndex > writerIndex || writerIndex > capacity()) {\n- throw new IndexOutOfBoundsException();\n- }\n- this.readerIndex = readerIndex;\n- this.writerIndex = writerIndex;\n- }\n-\n- @Override\n- public void clear() {\n- readerIndex = writerIndex = 0;\n- }\n-\n- @Override\n- public boolean readable() {\n- return readableBytes() > 0;\n- }\n-\n- @Override\n- public boolean writable() {\n- return writableBytes() > 0;\n- }\n-\n- @Override\n- public int readableBytes() {\n- return writerIndex - readerIndex;\n- }\n-\n- @Override\n- public int writableBytes() {\n- return capacity() - writerIndex;\n- }\n-\n- @Override\n- public void markReaderIndex() {\n- markedReaderIndex = readerIndex;\n- }\n-\n- @Override\n- public void resetReaderIndex() {\n- readerIndex(markedReaderIndex);\n- }\n-\n- @Override\n- public void markWriterIndex() {\n- markedWriterIndex = writerIndex;\n- }\n-\n- @Override\n- public void resetWriterIndex() {\n- writerIndex = markedWriterIndex;\n- }\n-\n- @Override\n- public void discardReadBytes() {\n- if (readerIndex == 0) {\n- return;\n- }\n- setBytes(0, this, readerIndex, writerIndex - readerIndex);\n- writerIndex -= readerIndex;\n- markedReaderIndex = Math.max(markedReaderIndex - readerIndex, 0);\n- markedWriterIndex = Math.max(markedWriterIndex - readerIndex, 0);\n- readerIndex = 0;\n- }\n-\n- @Override\n- public void ensureWritableBytes(int writableBytes) {\n- if (writableBytes > writableBytes()) {\n- throw new IndexOutOfBoundsException();\n- }\n- }\n-\n- @Override\n- public void getBytes(int index, byte[] dst) {\n- getBytes(index, dst, 0, dst.length);\n- }\n-\n- @Override\n- public void getBytes(int index, ChannelBuffer dst) {\n- getBytes(index, dst, dst.writableBytes());\n- }\n-\n- @Override\n- public void getBytes(int index, ChannelBuffer dst, int length) {\n- if (length > dst.writableBytes()) {\n- throw new IndexOutOfBoundsException();\n- }\n- getBytes(index, dst, dst.writerIndex(), length);\n- dst.writerIndex(dst.writerIndex() + length);\n- }\n-\n- @Override\n- public void setBytes(int index, byte[] src) {\n- setBytes(index, src, 0, src.length);\n- }\n-\n- @Override\n- public void setBytes(int index, ChannelBuffer src) {\n- setBytes(index, src, src.readableBytes());\n- }\n-\n- @Override\n- public void setBytes(int index, ChannelBuffer src, int length) {\n- if (length > src.readableBytes()) {\n- throw new IndexOutOfBoundsException();\n- }\n- setBytes(index, src, src.readerIndex(), length);\n- src.readerIndex(src.readerIndex() + length);\n- }\n-\n- @Override\n- public byte readByte() {\n- if (readerIndex == writerIndex) {\n- throw new IndexOutOfBoundsException();\n- }\n- return getByte(readerIndex++);\n- }\n-\n- @Override\n- public ChannelBuffer readBytes(int length) {\n- checkReadableBytes(length);\n- if (length == 0) {\n- return ChannelBuffers.EMPTY_BUFFER;\n- }\n- ChannelBuffer buf = factory().getBuffer(length);\n- buf.writeBytes(this, readerIndex, length);\n- readerIndex += length;\n- return buf;\n- }\n-\n- @Override\n- public void readBytes(byte[] dst, int dstIndex, int length) {\n- checkReadableBytes(length);\n- getBytes(readerIndex, dst, dstIndex, length);\n- readerIndex += length;\n- }\n-\n- @Override\n- public void readBytes(byte[] dst) {\n- readBytes(dst, 0, dst.length);\n- }\n-\n- @Override\n- public void readBytes(ChannelBuffer dst) {\n- readBytes(dst, dst.writableBytes());\n- }\n-\n- @Override\n- public void readBytes(ChannelBuffer dst, int length) {\n- if (length > dst.writableBytes()) {\n- throw new IndexOutOfBoundsException();\n- }\n- readBytes(dst, dst.writerIndex(), length);\n- dst.writerIndex(dst.writerIndex() + length);\n- }\n-\n- @Override\n- public void readBytes(ChannelBuffer dst, int dstIndex, int length) {\n- checkReadableBytes(length);\n- getBytes(readerIndex, dst, dstIndex, length);\n- readerIndex += length;\n- }\n-\n- @Override\n- public void readBytes(ByteBuffer dst) {\n- int length = dst.remaining();\n- checkReadableBytes(length);\n- getBytes(readerIndex, dst);\n- readerIndex += length;\n- }\n-\n- @Override\n- public void readBytes(OutputStream out, int length) throws IOException {\n- checkReadableBytes(length);\n- getBytes(readerIndex, out, length);\n- readerIndex += length;\n- }\n-\n- @Override\n- public void skipBytes(int length) {\n- int newReaderIndex = readerIndex + length;\n- if (newReaderIndex > writerIndex) {\n- throw new IndexOutOfBoundsException();\n- }\n- readerIndex = newReaderIndex;\n- }\n-\n- @Override\n- public void writeByte(int value) {\n- setByte(writerIndex++, value);\n- }\n-\n- @Override\n- public void writeBytes(byte[] src, int srcIndex, int length) {\n- setBytes(writerIndex, src, srcIndex, length);\n- writerIndex += length;\n- }\n-\n- @Override\n- public void writeBytes(byte[] src) {\n- writeBytes(src, 0, src.length);\n- }\n-\n- @Override\n- public void writeBytes(ChannelBuffer src) {\n- writeBytes(src, src.readableBytes());\n- }\n-\n- @Override\n- public void writeBytes(ChannelBuffer src, int length) {\n- if (length > src.readableBytes()) {\n- throw new IndexOutOfBoundsException();\n- }\n- writeBytes(src, src.readerIndex(), length);\n- src.readerIndex(src.readerIndex() + length);\n- }\n-\n- @Override\n- public void writeBytes(ChannelBuffer src, int srcIndex, int length) {\n- setBytes(writerIndex, src, srcIndex, length);\n- writerIndex += length;\n- }\n-\n- @Override\n- public void writeBytes(ByteBuffer src) {\n- int length = src.remaining();\n- setBytes(writerIndex, src);\n- writerIndex += length;\n- }\n-\n- @Override\n- public int writeBytes(InputStream in, int length) throws IOException {\n- int writtenBytes = setBytes(writerIndex, in, length);\n- if (writtenBytes > 0) {\n- writerIndex += writtenBytes;\n- }\n- return writtenBytes;\n- }\n-\n- @Override\n- public ChannelBuffer copy() {\n- return copy(readerIndex, readableBytes());\n- }\n-\n- @Override\n- public ByteBuffer toByteBuffer() {\n- return toByteBuffer(readerIndex, readableBytes());\n- }\n-\n- @Override\n- public boolean equals(Object o) {\n- return o instanceof ChannelBuffer\n- && ChannelBuffers.equals(this, (ChannelBuffer) o);\n- }\n-\n- @Override\n- public int hashCode() {\n- return ChannelBuffers.hasCode(this);\n- }\n-\n- @Override\n- public int compareTo(ChannelBuffer that) {\n- return ChannelBuffers.compare(this, that);\n- }\n-\n- @Override\n- public String toString() {\n- return getClass().getSimpleName() + '(' +\n- \"ridx=\" + readerIndex + \", \" +\n- \"widx=\" + writerIndex + \", \" +\n- \"cap=\" + capacity() +\n- ')';\n- }\n-\n- protected void checkReadableBytes(int minimumReadableBytes) {\n- if (readableBytes() < minimumReadableBytes) {\n- throw new IndexOutOfBoundsException();\n- }\n- }\n-}\n+/*\r\n+ * Licensed to the Apache Software Foundation (ASF) under one or more\r\n+ * contributor license agreements. See the NOTICE file distributed with\r\n+ * this work for additional information regarding copyright ownership.\r\n+ * The ASF licenses this file to You under the Apache License, Version 2.0\r\n+ * (the \"License\"); you may not use this file except in compliance with\r\n+ * the License. You may obtain a copy of the License at\r\n+ *\r\n+ * http://www.apache.org/licenses/LICENSE-2.0\r\n+ *\r\n+ * Unless required by applicable law or agreed to in writing, software\r\n+ * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n+ * See the License for the specific language governing permissions and\r\n+ * limitations under the License.\r\n+ */\r\n+\r\n+package org.apache.dubbo.remoting.buffer;\r\n+\r\n+import java.io.IOException;\r\n+import java.io.InputStream;\r\n+import java.io.OutputStream;\r\n+import java.nio.ByteBuffer;\r\n+\r\n+public abstract class AbstractChannelBuffer implements ChannelBuffer {\r\n+\r\n+ private int readerIndex;\r\n+\r\n+ private int writerIndex;\r\n+\r\n+ private int markedReaderIndex;\r\n+\r\n+ private int markedWriterIndex;\r\n+\r\n+ @Override\r\n+ public int readerIndex() {\r\n+ return readerIndex;\r\n+ }\r\n+\r\n+ @Override\r\n+ public void readerIndex(int readerIndex) {\r\n+ if (readerIndex < 0 || readerIndex > writerIndex) {\r\n+ throw new IndexOutOfBoundsException();\r\n+ }\r\n+ this.readerIndex = readerIndex;\r\n+ }\r\n+\r\n+ @Override\r\n+ public int writerIndex() {\r\n+ return writerIndex;\r\n+ }\r\n+\r\n+ @Override\r\n+ public void writerIndex(int writerIndex) {\r\n+ if (writerIndex < readerIndex || writerIndex > capacity()) {\r\n+ throw new IndexOutOfBoundsException();\r\n+ }\r\n+ this.writerIndex = writerIndex;\r\n+ }\r\n+\r\n+ @Override\r\n+ public void setIndex(int readerIndex, int writerIndex) {\r\n+ if (readerIndex < 0 || readerIndex > writerIndex || writerIndex > capacity()) {\r\n+ throw new IndexOutOfBoundsException();\r\n+ }\r\n+ this.readerIndex = readerIndex;\r\n+ this.writerIndex = writerIndex;\r\n+ }\r\n+\r\n+ @Override\r\n+ public void clear() {\r\n+ readerIndex = writerIndex = 0;\r\n+ }\r\n+\r\n+ @Override\r\n+ public boolean readable() {\r\n+ return readableBytes() > 0;\r\n+ }\r\n+\r\n+ @Override\r\n+ public boolean writable() {\r\n+ return writableBytes() > 0;\r\n+ }\r\n+\r\n+ @Override\r\n+ public int readableBytes() {\r\n+ return writerIndex - readerIndex;\r\n+ }\r\n+\r\n+ @Override\r\n+ public int writableBytes() {\r\n+ return capacity() - writerIndex;\r\n+ }\r\n+\r\n+ @Override\r\n+ public void markReaderIndex() {\r\n+ markedReaderIndex = readerIndex;\r\n+ }\r\n+\r\n+ @Override\r\n+ public void resetReaderIndex() {\r\n+ readerIndex(markedReaderIndex);\r\n+ }\r\n+\r\n+ @Override\r\n+ public void markWriterIndex() {\r\n+ markedWriterIndex = writerIndex;\r\n+ }\r\n+\r\n+ @Override\r\n+ public void resetWriterIndex() {\r\n+ writerIndex = markedWriterIndex;\r\n+ }\r\n+\r\n+ @Override\r\n+ public void discardReadBytes() {\r\n+ if (readerIndex == 0) {\r\n+ return;\r\n+ }\r\n+ setBytes(0, this, readerIndex, writerIndex - readerIndex);\r\n+ writerIndex -= readerIndex;\r\n+ markedReaderIndex = Math.max(markedReaderIndex - readerIndex, 0);\r\n+ markedWriterIndex = Math.max(markedWriterIndex - readerIndex, 0);\r\n+ readerIndex = 0;\r\n+ }\r\n+\r\n+ @Override\r\n+ public void ensureWritableBytes(int writableBytes) {\r\n+ if (writableBytes > writableBytes()) {\r\n+ throw new IndexOutOfBoundsException();\r\n+ }\r\n+ }\r\n+\r\n+ @Override\r\n+ public void getBytes(int index, byte[] dst) {\r\n+ getBytes(index, dst, 0, dst.length);\r\n+ }\r\n+\r\n+ @Override\r\n+ public void getBytes(int index, ChannelBuffer dst) {\r\n+ getBytes(index, dst, dst.writableBytes());\r\n+ }\r\n+\r\n+ @Override\r\n+ public void getBytes(int index, ChannelBuffer dst, int length) {\r\n+ if (length > dst.writableBytes()) {\r\n+ throw new IndexOutOfBoundsException();\r\n+ }\r\n+ getBytes(index, dst, dst.writerIndex(), length);\r\n+ dst.writerIndex(dst.writerIndex() + length);\r\n+ }\r\n+\r\n+ @Override\r\n+ public void setBytes(int index, byte[] src) {\r\n+ setBytes(index, src, 0, src.length);\r\n+ }\r\n+\r\n+ @Override\r\n+ public void setBytes(int index, ChannelBuffer src) {\r\n+ setBytes(index, src, src.readableBytes());\r\n+ }\r\n+\r\n+ @Override\r\n+ public void setBytes(int index, ChannelBuffer src, int length) {\r\n+ if (length > src.readableBytes()) {\r\n+ throw new IndexOutOfBoundsException();\r\n+ }\r\n+ setBytes(index, src, src.readerIndex(), length);\r\n+ src.readerIndex(src.readerIndex() + length);\r\n+ }\r\n+\r\n+ @Override\r\n+ public byte readByte() {\r\n+ if (readerIndex == writerIndex) {\r\n+ throw new IndexOutOfBoundsException();\r\n+ }\r\n+ return getByte(readerIndex++);\r\n+ }\r\n+\r\n+ @Override\r\n+ public ChannelBuffer readBytes(int length) {\r\n+ checkReadableBytes(length);\r\n+ if (length == 0) {\r\n+ return ChannelBuffers.EMPTY_BUFFER;\r\n+ }\r\n+ ChannelBuffer buf = factory().getBuffer(length);\r\n+ buf.writeBytes(this, readerIndex, length);\r\n+ readerIndex += length;\r\n+ return buf;\r\n+ }\r\n+\r\n+ @Override\r\n+ public void readBytes(byte[] dst, int dstIndex, int length) {\r\n+ checkReadableBytes(length);\r\n+ getBytes(readerIndex, dst, dstIndex, length);\r\n+ readerIndex += length;\r\n+ }\r\n+\r\n+ @Override\r\n+ public void readBytes(byte[] dst) {\r\n+ readBytes(dst, 0, dst.length);\r\n+ }\r\n+\r\n+ @Override\r\n+ public void readBytes(ChannelBuffer dst) {\r\n+ readBytes(dst, dst.writableBytes());\r\n+ }\r\n+\r\n+ @Override\r\n+ public void readBytes(ChannelBuffer dst, int length) {\r\n+ if (length > dst.writableBytes()) {\r\n+ throw new IndexOutOfBoundsException();\r\n+ }\r\n+ readBytes(dst, dst.writerIndex(), length);\r\n+ dst.writerIndex(dst.writerIndex() + length);\r\n+ }\r\n+\r\n+ @Override\r\n+ public void readBytes(ChannelBuffer dst, int dstIndex, int length) {\r\n+ checkReadableBytes(length);\r\n+ getBytes(readerIndex, dst, dstIndex, length);\r\n+ readerIndex += length;\r\n+ }\r\n+\r\n+ @Override\r\n+ public void readBytes(ByteBuffer dst) {\r\n+ int length = dst.remaining();\r\n+ checkReadableBytes(length);\r\n+ getBytes(readerIndex, dst);\r\n+ readerIndex += length;\r\n+ }\r\n+\r\n+ @Override\r\n+ public void readBytes(OutputStream out, int length) throws IOException {\r\n+ checkReadableBytes(length);\r\n+ getBytes(readerIndex, out, length);\r\n+ readerIndex += length;\r\n+ }\r\n+\r\n+ @Override\r\n+ public void skipBytes(int length) {\r\n+ int newReaderIndex = readerIndex + length;\r\n+ if (newReaderIndex > writerIndex) {\r\n+ throw new IndexOutOfBoundsException();\r\n+ }\r\n+ readerIndex = newReaderIndex;\r\n+ }\r\n+\r\n+ @Override\r\n+ public void writeByte(int value) {\r\n+ setByte(writerIndex++, value);\r\n+ }\r\n+\r\n+ @Override\r\n+ public void writeBytes(byte[] src, int srcIndex, int length) {\r\n+ setBytes(writerIndex, src, srcIndex, length);\r\n+ writerIndex += length;\r\n+ }\r\n+\r\n+ @Override\r\n+ public void writeBytes(byte[] src) {\r\n+ writeBytes(src, 0, src.length);\r\n+ }\r\n+\r\n+ @Override\r\n+ public void writeBytes(ChannelBuffer src) {\r\n+ writeBytes(src, src.readableBytes());\r\n+ }\r\n+\r\n+ @Override\r\n+ public void writeBytes(ChannelBuffer src, int length) {\r\n+ if (length > src.readableBytes()) {\r\n+ throw new IndexOutOfBoundsException();\r\n+ }\r\n+ writeBytes(src, src.readerIndex(), length);\r\n+ src.readerIndex(src.readerIndex() + length);\r\n+ }\r\n+\r\n+ @Override\r\n+ public void writeBytes(ChannelBuffer src, int srcIndex, int length) {\r\n+ setBytes(writerIndex, src, srcIndex, length);\r\n+ writerIndex += length;\r\n+ }\r\n+\r\n+ @Override\r\n+ public void writeBytes(ByteBuffer src) {\r\n+ int length = src.remaining();\r\n+ setBytes(writerIndex, src);\r\n+ writerIndex += length;\r\n+ }\r\n+\r\n+ @Override\r\n+ public int writeBytes(InputStream in, int length) throws IOException {\r\n+ int writtenBytes = setBytes(writerIndex, in, length);\r\n+ if (writtenBytes > 0) {\r\n+ writerIndex += writtenBytes;\r\n+ }\r\n+ return writtenBytes;\r\n+ }\r\n+\r\n+ @Override\r\n+ public ChannelBuffer copy() {\r\n+ return copy(readerIndex, readableBytes());\r\n+ }\r\n+\r\n+ @Override\r\n+ public ByteBuffer toByteBuffer() {\r\n+ return toByteBuffer(readerIndex, readableBytes());\r\n+ }\r\n+\r\n+ @Override\r\n+ public boolean equals(Object o) {\r\n+ return o instanceof ChannelBuffer\r\n+ && ChannelBuffers.equals(this, (ChannelBuffer) o);\r\n+ }\r\n+\r\n+ @Override\r\n+ public int hashCode() {\r\n+ return ChannelBuffers.hasCode(this);\r\n+ }\r\n+\r\n+ @Override\r\n+ public int compareTo(ChannelBuffer that) {\r\n+ return ChannelBuffers.compare(this, that);\r\n+ }\r\n+\r\n+ @Override\r\n+ public String toString() {\r\n+ return getClass().getSimpleName() + '(' +\r\n+ \"ridx=\" + readerIndex + \", \" +\r\n+ \"widx=\" + writerIndex + \", \" +\r\n+ \"cap=\" + capacity() +\r\n+ ')';\r\n+ }\r\n+\r\n+ protected void checkReadableBytes(int minimumReadableBytes) {\r\n+ if (readableBytes() < minimumReadableBytes) {\r\n+ throw new IndexOutOfBoundsException();\r\n+ }\r\n+ }\r\n+}\r\n"}, {"source1": "org/apache/dubbo/remoting/buffer/ChannelBuffer.java", "source2": "org/apache/dubbo/remoting/buffer/ChannelBuffer.java", "comments": ["Ordering differences only"], "unified_diff": "@@ -1,951 +1,951 @@\n-/*\n- * Licensed to the Apache Software Foundation (ASF) under one or more\n- * contributor license agreements. See the NOTICE file distributed with\n- * this work for additional information regarding copyright ownership.\n- * The ASF licenses this file to You under the Apache License, Version 2.0\n- * (the \"License\"); you may not use this file except in compliance with\n- * the License. You may obtain a copy of the License at\n- *\n- * http://www.apache.org/licenses/LICENSE-2.0\n- *\n- * Unless required by applicable law or agreed to in writing, software\n- * distributed under the License is distributed on an \"AS IS\" BASIS,\n- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n- * See the License for the specific language governing permissions and\n- * limitations under the License.\n- */\n-\n-package org.apache.dubbo.remoting.buffer;\n-\n-import java.io.IOException;\n-import java.io.InputStream;\n-import java.io.OutputStream;\n-import java.nio.ByteBuffer;\n-\n-/**\n- * A random and sequential accessible sequence of zero or more bytes (octets).\n- * This interface provides an abstract view for one or more primitive byte\n- * arrays ({@code byte[]}) and {@linkplain ByteBuffer NIO buffers}.\n- * Creation of a buffer
\n- * \n- * It is recommended to create a new buffer using the helper methods in {@link\n- * ChannelBuffers} rather than calling an individual implementation's\n- * constructor.\n- * \n- * Random Access Indexing
\n- * \n- * Just like an ordinary primitive byte array, {@link ChannelBuffer} uses \n- * {@link ChannelBuffer} buffer = ...;\n- * for (int i = 0; i < buffer.capacity(); i ++) {\n- * byte b = buffer.getByte(i);\n- * System.out.println((char) b);\n- * }\n- * \n- * \n- * Sequential Access Indexing
\n- * \n- * {@link ChannelBuffer} provides two pointer variables to support sequential\n- * read and write operations - {@link #readerIndex() readerIndex} for a read\n- * operation and {@link #writerIndex() writerIndex} for a write operation\n- * respectively. The following diagram shows how a buffer is segmented into\n- * three areas by the two pointers:\n- * \n- * \n- * +-------------------+------------------+------------------+\n- * | discardable bytes | readable bytes | writable bytes |\n- * | | (CONTENT) | |\n- * +-------------------+------------------+------------------+\n- * | | | |\n- * 0 <= readerIndex <= writerIndex <= capacity\n- *
\n- * \n- * Readable bytes (the actual content)
\n- * \n- * This segment is where the actual data is stored. Any operation whose name\n- * starts with {@code read} or {@code skip} will get or skip the data at the\n- * current {@link #readerIndex() readerIndex} and increase it by the number of\n- * read bytes. If the argument of the read operation is also a {@link\n- * ChannelBuffer} and no destination index is specified, the specified buffer's\n- * {@link #readerIndex() readerIndex} is increased together.\n- * \n- * If there's not enough content left, {@link IndexOutOfBoundsException} is\n- * raised. The default value of newly allocated, wrapped or copied buffer's\n- * {@link #readerIndex() readerIndex} is {@code 0}.\n- * \n- * \n- * // Iterates the readable bytes of a buffer.\n- * {@link ChannelBuffer} buffer = ...;\n- * while (buffer.readable()) {\n- * System.out.println(buffer.readByte());\n- * }\n- * \n- * \n- * Writable bytes
\n- * \n- * This segment is a undefined space which needs to be filled. Any operation\n- * whose name ends with {@code write} will write the data at the current {@link\n- * #writerIndex() writerIndex} and increase it by the number of written bytes.\n- * If the argument of the write operation is also a {@link ChannelBuffer}, and\n- * no source index is specified, the specified buffer's {@link #readerIndex()\n- * readerIndex} is increased together.\n- * \n- * If there's not enough writable bytes left, {@link IndexOutOfBoundsException}\n- * is raised. The default value of newly allocated buffer's {@link\n- * #writerIndex() writerIndex} is {@code 0}. The default value of wrapped or\n- * copied buffer's {@link #writerIndex() writerIndex} is the {@link #capacity()\n- * capacity} of the buffer.\n- * \n- * \n- * // Fills the writable bytes of a buffer with random integers.\n- * {@link ChannelBuffer} buffer = ...;\n- * while (buffer.writableBytes() >= 4) {\n- * buffer.writeInt(random.nextInt());\n- * }\n- * \n- * \n- * Discardable bytes
\n- * \n- * This segment contains the bytes which were read already by a read operation.\n- * Initially, the size of this segment is {@code 0}, but its size increases up\n- * to the {@link #writerIndex() writerIndex} as read operations are executed.\n- * The read bytes can be discarded by calling {@link #discardReadBytes()} to\n- * reclaim unused area as depicted by the following diagram:\n- * \n- * \n- * BEFORE discardReadBytes()\n- *\n- * +-------------------+------------------+------------------+\n- * | discardable bytes | readable bytes | writable bytes |\n- * +-------------------+------------------+------------------+\n- * | | | |\n- * 0 <= readerIndex <= writerIndex <= capacity\n- *\n- *\n- * AFTER discardReadBytes()\n- *\n- * +------------------+--------------------------------------+\n- * | readable bytes | writable bytes (got more space) |\n- * +------------------+--------------------------------------+\n- * | | |\n- * readerIndex (0) <= writerIndex (decreased) <= capacity\n- *
\n- * \n- * Please note that there is no guarantee about the content of writable bytes\n- * after calling {@link #discardReadBytes()}. The writable bytes will not be\n- * moved in most cases and could even be filled with completely different data\n- * depending on the underlying buffer implementation.\n- * \n- * Clearing the buffer indexes
\n- * \n- * You can set both {@link #readerIndex() readerIndex} and {@link #writerIndex()\n- * writerIndex} to {@code 0} by calling {@link #clear()}. It does not clear the\n- * buffer content (e.g. filling with {@code 0}) but just clears the two\n- * pointers. Please also note that the semantic of this operation is different\n- * from {@link ByteBuffer#clear()}.\n- * \n- * \n- * BEFORE clear()\n- *\n- * +-------------------+------------------+------------------+\n- * | discardable bytes | readable bytes | writable bytes |\n- * +-------------------+------------------+------------------+\n- * | | | |\n- * 0 <= readerIndex <= writerIndex <= capacity\n- *\n- *\n- * AFTER clear()\n- *\n- * +---------------------------------------------------------+\n- * | writable bytes (got more space) |\n- * +---------------------------------------------------------+\n- * | |\n- * 0 = readerIndex = writerIndex <= capacity\n- *
\n- * \n- * Mark and reset
\n- * \n- * There are two marker indexes in every buffer. One is for storing {@link\n- * #readerIndex() readerIndex} and the other is for storing {@link\n- * #writerIndex() writerIndex}. You can always reposition one of the two\n- * indexes by calling a reset method. It works in a similar fashion to the mark\n- * and reset methods in {@link InputStream} except that there's no {@code\n- * readlimit}.\n- * \n- * Conversion to existing JDK types
\n- * \n- * Byte array
\n- * \n- * If a {@link ChannelBuffer} is backed by a byte array (i.e. {@code byte[]}),\n- * you can access it directly via the {@link #array()} method. To determine if\n- * a buffer is backed by a byte array, {@link #hasArray()} should be used.\n- * \n- * NIO Buffers
\n- * \n- * Various {@link #toByteBuffer()} methods convert a {@link ChannelBuffer} into\n- * one or more NIO buffers. These methods avoid buffer allocation and memory\n- * copy whenever possible, but there's no guarantee that memory copy will not be\n- * involved.\n- * \n- * I/O Streams
\n- * \n- * Please refer to {@link ChannelBufferInputStream} and {@link\n- * ChannelBufferOutputStream}.\n- *\n- *\n- */\n-public interface ChannelBuffer extends Comparable
\n- *\n- * @param writableBytes the expected minimum number of writable bytes\n- * @throws IndexOutOfBoundsException if {@linkplain #writableBytes() the\n- * writable bytes} of this buffer is less\n- * than the specified value and if this\n- * buffer is not a dynamic buffer\n- */\n- void ensureWritableBytes(int writableBytes);\n-\n- /**\n- * Determines if the content of the specified buffer is identical to the\n- * content of this array. 'Identical' here means:
Please note that it\n- * does not compare {@link #readerIndex()} nor {@link #writerIndex()}. This\n- * method also returns {@code false} for {@code null} and an object which is\n- * not an instance of {@link ChannelBuffer} type.\n- */\n- @Override\n- boolean equals(Object o);\n-\n- /**\n- * Returns the factory which creates a {@link ChannelBuffer} whose type and\n- * default {@link java.nio.ByteOrder} are same with this buffer.\n- */\n- ChannelBufferFactory factory();\n-\n- /**\n- * Gets a byte at the specified absolute {@code index} in this buffer. This\n- * method does not modify {@code readerIndex} or {@code writerIndex} of this\n- * buffer.\n- *\n- * @throws IndexOutOfBoundsException if the specified {@code index} is less\n- * than {@code 0} or {@code index + 1} is\n- * greater than {@code this.capacity}\n- */\n- byte getByte(int index);\n-\n- /**\n- * Transfers this buffer's data to the specified destination starting at the\n- * specified absolute {@code index}. This method does not modify {@code\n- * readerIndex} or {@code writerIndex} of this buffer\n- *\n- * @throws IndexOutOfBoundsException if the specified {@code index} is less\n- * than {@code 0} or if {@code index +\n- * dst.length} is greater than {@code\n- * this.capacity}\n- */\n- void getBytes(int index, byte[] dst);\n-\n- /**\n- * Transfers this buffer's data to the specified destination starting at the\n- * specified absolute {@code index}. This method does not modify {@code\n- * readerIndex} or {@code writerIndex} of this buffer.\n- *\n- * @param dstIndex the first index of the destination\n- * @param length the number of bytes to transfer\n- * @throws IndexOutOfBoundsException if the specified {@code index} is less\n- * than {@code 0}, if the specified {@code\n- * dstIndex} is less than {@code 0}, if\n- * {@code index + length} is greater than\n- * {@code this.capacity}, or if {@code\n- * dstIndex + length} is greater than\n- * {@code dst.length}\n- */\n- void getBytes(int index, byte[] dst, int dstIndex, int length);\n-\n- /**\n- * Transfers this buffer's data to the specified destination starting at the\n- * specified absolute {@code index} until the destination's position reaches\n- * its limit. This method does not modify {@code readerIndex} or {@code\n- * writerIndex} of this buffer while the destination's {@code position} will\n- * be increased.\n- *\n- * @throws IndexOutOfBoundsException if the specified {@code index} is less\n- * than {@code 0} or if {@code index +\n- * dst.remaining()} is greater than {@code\n- * this.capacity}\n- */\n- void getBytes(int index, ByteBuffer dst);\n-\n- /**\n- * Transfers this buffer's data to the specified destination starting at the\n- * specified absolute {@code index} until the destination becomes\n- * non-writable. This method is basically same with {@link #getBytes(int,\n- * ChannelBuffer, int, int)}, except that this method increases the {@code\n- * writerIndex} of the destination by the number of the transferred bytes\n- * while {@link #getBytes(int, ChannelBuffer, int, int)} does not. This\n- * method does not modify {@code readerIndex} or {@code writerIndex} of the\n- * source buffer (i.e. {@code this}).\n- *\n- * @throws IndexOutOfBoundsException if the specified {@code index} is less\n- * than {@code 0} or if {@code index +\n- * dst.writableBytes} is greater than\n- * {@code this.capacity}\n- */\n- void getBytes(int index, ChannelBuffer dst);\n-\n- /**\n- * Transfers this buffer's data to the specified destination starting at the\n- * specified absolute {@code index}. This method is basically same with\n- * {@link #getBytes(int, ChannelBuffer, int, int)}, except that this method\n- * increases the {@code writerIndex} of the destination by the number of the\n- * transferred bytes while {@link #getBytes(int, ChannelBuffer, int, int)}\n- * does not. This method does not modify {@code readerIndex} or {@code\n- * writerIndex} of the source buffer (i.e. {@code this}).\n- *\n- * @param length the number of bytes to transfer\n- * @throws IndexOutOfBoundsException if the specified {@code index} is less\n- * than {@code 0}, if {@code index +\n- * length} is greater than {@code\n- * this.capacity}, or if {@code length} is\n- * greater than {@code dst.writableBytes}\n- */\n- void getBytes(int index, ChannelBuffer dst, int length);\n-\n- /**\n- * Transfers this buffer's data to the specified destination starting at the\n- * specified absolute {@code index}. This method does not modify {@code\n- * readerIndex} or {@code writerIndex} of both the source (i.e. {@code\n- * this}) and the destination.\n- *\n- * @param dstIndex the first index of the destination\n- * @param length the number of bytes to transfer\n- * @throws IndexOutOfBoundsException if the specified {@code index} is less\n- * than {@code 0}, if the specified {@code\n- * dstIndex} is less than {@code 0}, if\n- * {@code index + length} is greater than\n- * {@code this.capacity}, or if {@code\n- * dstIndex + length} is greater than\n- * {@code dst.capacity}\n- */\n- void getBytes(int index, ChannelBuffer dst, int dstIndex, int length);\n-\n- /**\n- * Transfers this buffer's data to the specified stream starting at the\n- * specified absolute {@code index}. This method does not modify {@code\n- * readerIndex} or {@code writerIndex} of this buffer.\n- *\n- * @param length the number of bytes to transfer\n- * @throws IndexOutOfBoundsException if the specified {@code index} is less\n- * than {@code 0} or if {@code index +\n- * length} is greater than {@code\n- * this.capacity}\n- * @throws IOException if the specified stream threw an\n- * exception during I/O\n- */\n- void getBytes(int index, OutputStream dst, int length) throws IOException;\n-\n- /**\n- * Returns {@code true} if and only if this buffer is backed by an NIO\n- * direct buffer.\n- */\n- boolean isDirect();\n-\n- /**\n- * Marks the current {@code readerIndex} in this buffer. You can reposition\n- * the current {@code readerIndex} to the marked {@code readerIndex} by\n- * calling {@link #resetReaderIndex()}. The initial value of the marked\n- * {@code readerIndex} is {@code 0}.\n- */\n- void markReaderIndex();\n-\n- /**\n- * Marks the current {@code writerIndex} in this buffer. You can reposition\n- * the current {@code writerIndex} to the marked {@code writerIndex} by\n- * calling {@link #resetWriterIndex()}. The initial value of the marked\n- * {@code writerIndex} is {@code 0}.\n- */\n- void markWriterIndex();\n-\n- /**\n- * Returns {@code true} if and only if {@code (this.writerIndex -\n- * this.readerIndex)} is greater than {@code 0}.\n- */\n- boolean readable();\n-\n- /**\n- * Returns the number of readable bytes which is equal to {@code\n- * (this.writerIndex - this.readerIndex)}.\n- */\n- int readableBytes();\n-\n- /**\n- * Gets a byte at the current {@code readerIndex} and increases the {@code\n- * readerIndex} by {@code 1} in this buffer.\n- *\n- * @throws IndexOutOfBoundsException if {@code this.readableBytes} is less\n- * than {@code 1}\n- */\n- byte readByte();\n-\n- /**\n- * Transfers this buffer's data to the specified destination starting at the\n- * current {@code readerIndex} and increases the {@code readerIndex} by the\n- * number of the transferred bytes (= {@code dst.length}).\n- *\n- * @throws IndexOutOfBoundsException if {@code dst.length} is greater than\n- * {@code this.readableBytes}\n- */\n- void readBytes(byte[] dst);\n-\n- /**\n- * Transfers this buffer's data to the specified destination starting at the\n- * current {@code readerIndex} and increases the {@code readerIndex} by the\n- * number of the transferred bytes (= {@code length}).\n- *\n- * @param dstIndex the first index of the destination\n- * @param length the number of bytes to transfer\n- * @throws IndexOutOfBoundsException if the specified {@code dstIndex} is\n- * less than {@code 0}, if {@code length}\n- * is greater than {@code this.readableBytes},\n- * or if {@code dstIndex + length} is\n- * greater than {@code dst.length}\n- */\n- void readBytes(byte[] dst, int dstIndex, int length);\n-\n- /**\n- * Transfers this buffer's data to the specified destination starting at the\n- * current {@code readerIndex} until the destination's position reaches its\n- * limit, and increases the {@code readerIndex} by the number of the\n- * transferred bytes.\n- *\n- * @throws IndexOutOfBoundsException if {@code dst.remaining()} is greater\n- * than {@code this.readableBytes}\n- */\n- void readBytes(ByteBuffer dst);\n-\n- /**\n- * Transfers this buffer's data to the specified destination starting at the\n- * current {@code readerIndex} until the destination becomes non-writable,\n- * and increases the {@code readerIndex} by the number of the transferred\n- * bytes. This method is basically same with {@link\n- * #readBytes(ChannelBuffer, int, int)}, except that this method increases\n- * the {@code writerIndex} of the destination by the number of the\n- * transferred bytes while {@link #readBytes(ChannelBuffer, int, int)} does\n- * not.\n- *\n- * @throws IndexOutOfBoundsException if {@code dst.writableBytes} is greater\n- * than {@code this.readableBytes}\n- */\n- void readBytes(ChannelBuffer dst);\n-\n- /**\n- * Transfers this buffer's data to the specified destination starting at the\n- * current {@code readerIndex} and increases the {@code readerIndex} by the\n- * number of the transferred bytes (= {@code length}). This method is\n- * basically same with {@link #readBytes(ChannelBuffer, int, int)}, except\n- * that this method increases the {@code writerIndex} of the destination by\n- * the number of the transferred bytes (= {@code length}) while {@link\n- * #readBytes(ChannelBuffer, int, int)} does not.\n- *\n- * @throws IndexOutOfBoundsException if {@code length} is greater than\n- * {@code this.readableBytes} or if {@code\n- * length} is greater than {@code\n- * dst.writableBytes}\n- */\n- void readBytes(ChannelBuffer dst, int length);\n-\n- /**\n- * Transfers this buffer's data to the specified destination starting at the\n- * current {@code readerIndex} and increases the {@code readerIndex} by the\n- * number of the transferred bytes (= {@code length}).\n- *\n- * @param dstIndex the first index of the destination\n- * @param length the number of bytes to transfer\n- * @throws IndexOutOfBoundsException if the specified {@code dstIndex} is\n- * less than {@code 0}, if {@code length}\n- * is greater than {@code this.readableBytes},\n- * or if {@code dstIndex + length} is\n- * greater than {@code dst.capacity}\n- */\n- void readBytes(ChannelBuffer dst, int dstIndex, int length);\n-\n- /**\n- * Transfers this buffer's data to a newly created buffer starting at the\n- * current {@code readerIndex} and increases the {@code readerIndex} by the\n- * number of the transferred bytes (= {@code length}). The returned buffer's\n- * {@code readerIndex} and {@code writerIndex} are {@code 0} and {@code\n- * length} respectively.\n- *\n- * @param length the number of bytes to transfer\n- * @return the newly created buffer which contains the transferred bytes\n- * @throws IndexOutOfBoundsException if {@code length} is greater than\n- * {@code this.readableBytes}\n- */\n- ChannelBuffer readBytes(int length);\n-\n- /**\n- * Repositions the current {@code readerIndex} to the marked {@code\n- * readerIndex} in this buffer.\n- *\n- * @throws IndexOutOfBoundsException if the current {@code writerIndex} is\n- * less than the marked {@code\n- * readerIndex}\n- */\n- void resetReaderIndex();\n-\n- /**\n- * Marks the current {@code writerIndex} in this buffer. You can reposition\n- * the current {@code writerIndex} to the marked {@code writerIndex} by\n- * calling {@link #resetWriterIndex()}. The initial value of the marked\n- * {@code writerIndex} is {@code 0}.\n- */\n- void resetWriterIndex();\n-\n- /**\n- * Returns the {@code readerIndex} of this buffer.\n- */\n- int readerIndex();\n-\n- /**\n- * Sets the {@code readerIndex} of this buffer.\n- *\n- * @throws IndexOutOfBoundsException if the specified {@code readerIndex} is\n- * less than {@code 0} or greater than\n- * {@code this.writerIndex}\n- */\n- void readerIndex(int readerIndex);\n-\n- /**\n- * Transfers this buffer's data to the specified stream starting at the\n- * current {@code readerIndex}.\n- *\n- * @param length the number of bytes to transfer\n- * @throws IndexOutOfBoundsException if {@code length} is greater than\n- * {@code this.readableBytes}\n- * @throws IOException if the specified stream threw an\n- * exception during I/O\n- */\n- void readBytes(OutputStream dst, int length) throws IOException;\n-\n- /**\n- * Sets the specified byte at the specified absolute {@code index} in this\n- * buffer. The 24 high-order bits of the specified value are ignored. This\n- * method does not modify {@code readerIndex} or {@code writerIndex} of this\n- * buffer.\n- *\n- * @throws IndexOutOfBoundsException if the specified {@code index} is less\n- * than {@code 0} or {@code index + 1} is\n- * greater than {@code this.capacity}\n- */\n- void setByte(int index, int value);\n-\n- /**\n- * Transfers the specified source array's data to this buffer starting at\n- * the specified absolute {@code index}. This method does not modify {@code\n- * readerIndex} or {@code writerIndex} of this buffer.\n- *\n- * @throws IndexOutOfBoundsException if the specified {@code index} is less\n- * than {@code 0} or if {@code index +\n- * src.length} is greater than {@code\n- * this.capacity}\n- */\n- void setBytes(int index, byte[] src);\n-\n- /**\n- * Transfers the specified source array's data to this buffer starting at\n- * the specified absolute {@code index}. This method does not modify {@code\n- * readerIndex} or {@code writerIndex} of this buffer.\n- *\n- * @throws IndexOutOfBoundsException if the specified {@code index} is less\n- * than {@code 0}, if the specified {@code\n- * srcIndex} is less than {@code 0}, if\n- * {@code index + length} is greater than\n- * {@code this.capacity}, or if {@code\n- * srcIndex + length} is greater than\n- * {@code src.length}\n- */\n- void setBytes(int index, byte[] src, int srcIndex, int length);\n-\n- /**\n- * Transfers the specified source buffer's data to this buffer starting at\n- * the specified absolute {@code index} until the source buffer's position\n- * reaches its limit. This method does not modify {@code readerIndex} or\n- * {@code writerIndex} of this buffer.\n- *\n- * @throws IndexOutOfBoundsException if the specified {@code index} is less\n- * than {@code 0} or if {@code index +\n- * src.remaining()} is greater than {@code\n- * this.capacity}\n- */\n- void setBytes(int index, ByteBuffer src);\n-\n- /**\n- * Transfers the specified source buffer's data to this buffer starting at\n- * the specified absolute {@code index} until the source buffer becomes\n- * unreadable. This method is basically same with {@link #setBytes(int,\n- * ChannelBuffer, int, int)}, except that this method increases the {@code\n- * readerIndex} of the source buffer by the number of the transferred bytes\n- * while {@link #setBytes(int, ChannelBuffer, int, int)} does not. This\n- * method does not modify {@code readerIndex} or {@code writerIndex} of the\n- * source buffer (i.e. {@code this}).\n- *\n- * @throws IndexOutOfBoundsException if the specified {@code index} is less\n- * than {@code 0} or if {@code index +\n- * src.readableBytes} is greater than\n- * {@code this.capacity}\n- */\n- void setBytes(int index, ChannelBuffer src);\n-\n- /**\n- * Transfers the specified source buffer's data to this buffer starting at\n- * the specified absolute {@code index}. This method is basically same with\n- * {@link #setBytes(int, ChannelBuffer, int, int)}, except that this method\n- * increases the {@code readerIndex} of the source buffer by the number of\n- * the transferred bytes while {@link #setBytes(int, ChannelBuffer, int,\n- * int)} does not. This method does not modify {@code readerIndex} or {@code\n- * writerIndex} of the source buffer (i.e. {@code this}).\n- *\n- * @param length the number of bytes to transfer\n- * @throws IndexOutOfBoundsException if the specified {@code index} is less\n- * than {@code 0}, if {@code index +\n- * length} is greater than {@code\n- * this.capacity}, or if {@code length} is\n- * greater than {@code src.readableBytes}\n- */\n- void setBytes(int index, ChannelBuffer src, int length);\n-\n- /**\n- * Transfers the specified source buffer's data to this buffer starting at\n- * the specified absolute {@code index}. This method does not modify {@code\n- * readerIndex} or {@code writerIndex} of both the source (i.e. {@code\n- * this}) and the destination.\n- *\n- * @param srcIndex the first index of the source\n- * @param length the number of bytes to transfer\n- * @throws IndexOutOfBoundsException if the specified {@code index} is less\n- * than {@code 0}, if the specified {@code\n- * srcIndex} is less than {@code 0}, if\n- * {@code index + length} is greater than\n- * {@code this.capacity}, or if {@code\n- * srcIndex + length} is greater than\n- * {@code src.capacity}\n- */\n- void setBytes(int index, ChannelBuffer src, int srcIndex, int length);\n-\n- /**\n- * Transfers the content of the specified source stream to this buffer\n- * starting at the specified absolute {@code index}. This method does not\n- * modify {@code readerIndex} or {@code writerIndex} of this buffer.\n- *\n- * @param length the number of bytes to transfer\n- * @return the actual number of bytes read in from the specified channel.\n- * {@code -1} if the specified channel is closed.\n- * @throws IndexOutOfBoundsException if the specified {@code index} is less\n- * than {@code 0} or if {@code index +\n- * length} is greater than {@code\n- * this.capacity}\n- * @throws IOException if the specified stream threw an\n- * exception during I/O\n- */\n- int setBytes(int index, InputStream src, int length) throws IOException;\n-\n- /**\n- * Sets the {@code readerIndex} and {@code writerIndex} of this buffer in\n- * one shot. This method is useful when you have to worry about the\n- * invocation order of {@link #readerIndex(int)} and {@link\n- * #writerIndex(int)} methods. For example, the following code will fail:\n- * \n- * \n- * // Create a buffer whose readerIndex, writerIndex and capacity are\n- * // 0, 0 and 8 respectively.\n- * {@link ChannelBuffer} buf = {@link ChannelBuffers}.buffer(8);\n- *\n- * // IndexOutOfBoundsException is thrown because the specified\n- * // readerIndex (2) cannot be greater than the current writerIndex (0).\n- * buf.readerIndex(2);\n- * buf.writerIndex(4);\n- * \n- * \n- * The following code will also fail:\n- * \n- * \n- * // Create a buffer whose readerIndex, writerIndex and capacity are\n- * // 0, 8 and 8 respectively.\n- * {@link ChannelBuffer} buf = {@link ChannelBuffers}.wrappedBuffer(new\n- * byte[8]);\n- *\n- * // readerIndex becomes 8.\n- * buf.readLong();\n- *\n- * // IndexOutOfBoundsException is thrown because the specified\n- * // writerIndex (4) cannot be less than the current readerIndex (8).\n- * buf.writerIndex(4);\n- * buf.readerIndex(2);\n- * \n- * \n- * By contrast, {@link #setIndex(int, int)} guarantees that it never throws\n- * an {@link IndexOutOfBoundsException} as long as the specified indexes\n- * meet basic constraints, regardless what the current index values of the\n- * buffer are:\n- * \n- * \n- * // No matter what the current state of the buffer is, the following\n- * // call always succeeds as long as the capacity of the buffer is not\n- * // less than 4.\n- * buf.setIndex(2, 4);\n- *
\n- *\n- * @throws IndexOutOfBoundsException if the specified {@code readerIndex} is\n- * less than 0, if the specified {@code\n- * writerIndex} is less than the specified\n- * {@code readerIndex} or if the specified\n- * {@code writerIndex} is greater than\n- * {@code this.capacity}\n- */\n- void setIndex(int readerIndex, int writerIndex);\n-\n- /**\n- * Increases the current {@code readerIndex} by the specified {@code length}\n- * in this buffer.\n- *\n- * @throws IndexOutOfBoundsException if {@code length} is greater than\n- * {@code this.readableBytes}\n- */\n- void skipBytes(int length);\n-\n- /**\n- * Converts this buffer's readable bytes into a NIO buffer. The returned\n- * buffer might or might not share the content with this buffer, while they\n- * have separate indexes and marks. This method is identical to {@code\n- * buf.toByteBuffer(buf.readerIndex(), buf.readableBytes())}. This method\n- * does not modify {@code readerIndex} or {@code writerIndex} of this\n- * buffer.\n- */\n- ByteBuffer toByteBuffer();\n-\n- /**\n- * Converts this buffer's sub-region into a NIO buffer. The returned buffer\n- * might or might not share the content with this buffer, while they have\n- * separate indexes and marks. This method does not modify {@code\n- * readerIndex} or {@code writerIndex} of this buffer.\n- */\n- ByteBuffer toByteBuffer(int index, int length);\n-\n- /**\n- * Returns {@code true} if and only if {@code (this.capacity -\n- * this.writerIndex)} is greater than {@code 0}.\n- */\n- boolean writable();\n-\n- /**\n- * Returns the number of writable bytes which is equal to {@code\n- * (this.capacity - this.writerIndex)}.\n- */\n- int writableBytes();\n-\n- /**\n- * Sets the specified byte at the current {@code writerIndex} and increases\n- * the {@code writerIndex} by {@code 1} in this buffer. The 24 high-order\n- * bits of the specified value are ignored.\n- *\n- * @throws IndexOutOfBoundsException if {@code this.writableBytes} is less\n- * than {@code 1}\n- */\n- void writeByte(int value);\n-\n- /**\n- * Transfers the specified source array's data to this buffer starting at\n- * the current {@code writerIndex} and increases the {@code writerIndex} by\n- * the number of the transferred bytes (= {@code src.length}).\n- *\n- * @throws IndexOutOfBoundsException if {@code src.length} is greater than\n- * {@code this.writableBytes}\n- */\n- void writeBytes(byte[] src);\n-\n- /**\n- * Transfers the specified source array's data to this buffer starting at\n- * the current {@code writerIndex} and increases the {@code writerIndex} by\n- * the number of the transferred bytes (= {@code length}).\n- *\n- * @param index the first index of the source\n- * @param length the number of bytes to transfer\n- * @throws IndexOutOfBoundsException if the specified {@code srcIndex} is\n- * less than {@code 0}, if {@code srcIndex\n- * + length} is greater than {@code\n- * src.length}, or if {@code length} is\n- * greater than {@code this.writableBytes}\n- */\n- void writeBytes(byte[] src, int index, int length);\n-\n- /**\n- * Transfers the specified source buffer's data to this buffer starting at\n- * the current {@code writerIndex} until the source buffer's position\n- * reaches its limit, and increases the {@code writerIndex} by the number of\n- * the transferred bytes.\n- *\n- * @throws IndexOutOfBoundsException if {@code src.remaining()} is greater\n- * than {@code this.writableBytes}\n- */\n- void writeBytes(ByteBuffer src);\n-\n- /**\n- * Transfers the specified source buffer's data to this buffer starting at\n- * the current {@code writerIndex} until the source buffer becomes\n- * unreadable, and increases the {@code writerIndex} by the number of the\n- * transferred bytes. This method is basically same with {@link\n- * #writeBytes(ChannelBuffer, int, int)}, except that this method increases\n- * the {@code readerIndex} of the source buffer by the number of the\n- * transferred bytes while {@link #writeBytes(ChannelBuffer, int, int)} does\n- * not.\n- *\n- * @throws IndexOutOfBoundsException if {@code src.readableBytes} is greater\n- * than {@code this.writableBytes}\n- */\n- void writeBytes(ChannelBuffer src);\n-\n- /**\n- * Transfers the specified source buffer's data to this buffer starting at\n- * the current {@code writerIndex} and increases the {@code writerIndex} by\n- * the number of the transferred bytes (= {@code length}). This method is\n- * basically same with {@link #writeBytes(ChannelBuffer, int, int)}, except\n- * that this method increases the {@code readerIndex} of the source buffer\n- * by the number of the transferred bytes (= {@code length}) while {@link\n- * #writeBytes(ChannelBuffer, int, int)} does not.\n- *\n- * @param length the number of bytes to transfer\n- * @throws IndexOutOfBoundsException if {@code length} is greater than\n- * {@code this.writableBytes} or if {@code\n- * length} is greater then {@code\n- * src.readableBytes}\n- */\n- void writeBytes(ChannelBuffer src, int length);\n-\n- /**\n- * Transfers the specified source buffer's data to this buffer starting at\n- * the current {@code writerIndex} and increases the {@code writerIndex} by\n- * the number of the transferred bytes (= {@code length}).\n- *\n- * @param srcIndex the first index of the source\n- * @param length the number of bytes to transfer\n- * @throws IndexOutOfBoundsException if the specified {@code srcIndex} is\n- * less than {@code 0}, if {@code srcIndex\n- * + length} is greater than {@code\n- * src.capacity}, or if {@code length} is\n- * greater than {@code this.writableBytes}\n- */\n- void writeBytes(ChannelBuffer src, int srcIndex, int length);\n-\n- /**\n- * Transfers the content of the specified stream to this buffer starting at\n- * the current {@code writerIndex} and increases the {@code writerIndex} by\n- * the number of the transferred bytes.\n- *\n- * @param length the number of bytes to transfer\n- * @return the actual number of bytes read in from the specified stream\n- * @throws IndexOutOfBoundsException if {@code length} is greater than\n- * {@code this.writableBytes}\n- * @throws IOException if the specified stream threw an\n- * exception during I/O\n- */\n- int writeBytes(InputStream src, int length) throws IOException;\n-\n- /**\n- * Returns the {@code writerIndex} of this buffer.\n- */\n- int writerIndex();\n-\n- /**\n- * Sets the {@code writerIndex} of this buffer.\n- *\n- * @throws IndexOutOfBoundsException if the specified {@code writerIndex} is\n- * less than {@code this.readerIndex} or\n- * greater than {@code this.capacity}\n- */\n- void writerIndex(int writerIndex);\n-\n- /**\n- * Returns the backing byte array of this buffer.\n- *\n- * @throws UnsupportedOperationException if there no accessible backing byte\n- * array\n- */\n- byte[] array();\n-\n- /**\n- * Returns {@code true} if and only if this buffer has a backing byte array.\n- * If this method returns true, you can safely call {@link #array()} and\n- * {@link #arrayOffset()}.\n- */\n- boolean hasArray();\n-\n- /**\n- * Returns the offset of the first byte within the backing byte array of\n- * this buffer.\n- *\n- * @throws UnsupportedOperationException if there no accessible backing byte\n- * array\n- */\n- int arrayOffset();\n-}\n+/*\r\n+ * Licensed to the Apache Software Foundation (ASF) under one or more\r\n+ * contributor license agreements. See the NOTICE file distributed with\r\n+ * this work for additional information regarding copyright ownership.\r\n+ * The ASF licenses this file to You under the Apache License, Version 2.0\r\n+ * (the \"License\"); you may not use this file except in compliance with\r\n+ * the License. You may obtain a copy of the License at\r\n+ *\r\n+ * http://www.apache.org/licenses/LICENSE-2.0\r\n+ *\r\n+ * Unless required by applicable law or agreed to in writing, software\r\n+ * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n+ * See the License for the specific language governing permissions and\r\n+ * limitations under the License.\r\n+ */\r\n+\r\n+package org.apache.dubbo.remoting.buffer;\r\n+\r\n+import java.io.IOException;\r\n+import java.io.InputStream;\r\n+import java.io.OutputStream;\r\n+import java.nio.ByteBuffer;\r\n+\r\n+/**\r\n+ * A random and sequential accessible sequence of zero or more bytes (octets).\r\n+ * This interface provides an abstract view for one or more primitive byte\r\n+ * arrays ({@code byte[]}) and {@linkplain ByteBuffer NIO buffers}.\r\n+ * \r\n+ * Creation of a buffer
\r\n+ * \r\n+ * It is recommended to create a new buffer using the helper methods in {@link\r\n+ * ChannelBuffers} rather than calling an individual implementation's\r\n+ * constructor.\r\n+ * \r\n+ * Random Access Indexing
\r\n+ * \r\n+ * Just like an ordinary primitive byte array, {@link ChannelBuffer} uses \r\n+ * {@link ChannelBuffer} buffer = ...;\r\n+ * for (int i = 0; i < buffer.capacity(); i ++) {\r\n+ * byte b = buffer.getByte(i);\r\n+ * System.out.println((char) b);\r\n+ * }\r\n+ * \r\n+ * \r\n+ * Sequential Access Indexing
\r\n+ * \r\n+ * {@link ChannelBuffer} provides two pointer variables to support sequential\r\n+ * read and write operations - {@link #readerIndex() readerIndex} for a read\r\n+ * operation and {@link #writerIndex() writerIndex} for a write operation\r\n+ * respectively. The following diagram shows how a buffer is segmented into\r\n+ * three areas by the two pointers:\r\n+ * \r\n+ * \r\n+ * +-------------------+------------------+------------------+\r\n+ * | discardable bytes | readable bytes | writable bytes |\r\n+ * | | (CONTENT) | |\r\n+ * +-------------------+------------------+------------------+\r\n+ * | | | |\r\n+ * 0 <= readerIndex <= writerIndex <= capacity\r\n+ *
\r\n+ * \r\n+ * Readable bytes (the actual content)
\r\n+ * \r\n+ * This segment is where the actual data is stored. Any operation whose name\r\n+ * starts with {@code read} or {@code skip} will get or skip the data at the\r\n+ * current {@link #readerIndex() readerIndex} and increase it by the number of\r\n+ * read bytes. If the argument of the read operation is also a {@link\r\n+ * ChannelBuffer} and no destination index is specified, the specified buffer's\r\n+ * {@link #readerIndex() readerIndex} is increased together.\r\n+ * \r\n+ * If there's not enough content left, {@link IndexOutOfBoundsException} is\r\n+ * raised. The default value of newly allocated, wrapped or copied buffer's\r\n+ * {@link #readerIndex() readerIndex} is {@code 0}.\r\n+ * \r\n+ * \r\n+ * // Iterates the readable bytes of a buffer.\r\n+ * {@link ChannelBuffer} buffer = ...;\r\n+ * while (buffer.readable()) {\r\n+ * System.out.println(buffer.readByte());\r\n+ * }\r\n+ * \r\n+ * \r\n+ * Writable bytes
\r\n+ * \r\n+ * This segment is a undefined space which needs to be filled. Any operation\r\n+ * whose name ends with {@code write} will write the data at the current {@link\r\n+ * #writerIndex() writerIndex} and increase it by the number of written bytes.\r\n+ * If the argument of the write operation is also a {@link ChannelBuffer}, and\r\n+ * no source index is specified, the specified buffer's {@link #readerIndex()\r\n+ * readerIndex} is increased together.\r\n+ * \r\n+ * If there's not enough writable bytes left, {@link IndexOutOfBoundsException}\r\n+ * is raised. The default value of newly allocated buffer's {@link\r\n+ * #writerIndex() writerIndex} is {@code 0}. The default value of wrapped or\r\n+ * copied buffer's {@link #writerIndex() writerIndex} is the {@link #capacity()\r\n+ * capacity} of the buffer.\r\n+ * \r\n+ * \r\n+ * // Fills the writable bytes of a buffer with random integers.\r\n+ * {@link ChannelBuffer} buffer = ...;\r\n+ * while (buffer.writableBytes() >= 4) {\r\n+ * buffer.writeInt(random.nextInt());\r\n+ * }\r\n+ * \r\n+ * \r\n+ * Discardable bytes
\r\n+ * \r\n+ * This segment contains the bytes which were read already by a read operation.\r\n+ * Initially, the size of this segment is {@code 0}, but its size increases up\r\n+ * to the {@link #writerIndex() writerIndex} as read operations are executed.\r\n+ * The read bytes can be discarded by calling {@link #discardReadBytes()} to\r\n+ * reclaim unused area as depicted by the following diagram:\r\n+ * \r\n+ * \r\n+ * BEFORE discardReadBytes()\r\n+ *\r\n+ * +-------------------+------------------+------------------+\r\n+ * | discardable bytes | readable bytes | writable bytes |\r\n+ * +-------------------+------------------+------------------+\r\n+ * | | | |\r\n+ * 0 <= readerIndex <= writerIndex <= capacity\r\n+ *\r\n+ *\r\n+ * AFTER discardReadBytes()\r\n+ *\r\n+ * +------------------+--------------------------------------+\r\n+ * | readable bytes | writable bytes (got more space) |\r\n+ * +------------------+--------------------------------------+\r\n+ * | | |\r\n+ * readerIndex (0) <= writerIndex (decreased) <= capacity\r\n+ *
\r\n+ * \r\n+ * Please note that there is no guarantee about the content of writable bytes\r\n+ * after calling {@link #discardReadBytes()}. The writable bytes will not be\r\n+ * moved in most cases and could even be filled with completely different data\r\n+ * depending on the underlying buffer implementation.\r\n+ * \r\n+ * Clearing the buffer indexes
\r\n+ * \r\n+ * You can set both {@link #readerIndex() readerIndex} and {@link #writerIndex()\r\n+ * writerIndex} to {@code 0} by calling {@link #clear()}. It does not clear the\r\n+ * buffer content (e.g. filling with {@code 0}) but just clears the two\r\n+ * pointers. Please also note that the semantic of this operation is different\r\n+ * from {@link ByteBuffer#clear()}.\r\n+ * \r\n+ * \r\n+ * BEFORE clear()\r\n+ *\r\n+ * +-------------------+------------------+------------------+\r\n+ * | discardable bytes | readable bytes | writable bytes |\r\n+ * +-------------------+------------------+------------------+\r\n+ * | | | |\r\n+ * 0 <= readerIndex <= writerIndex <= capacity\r\n+ *\r\n+ *\r\n+ * AFTER clear()\r\n+ *\r\n+ * +---------------------------------------------------------+\r\n+ * | writable bytes (got more space) |\r\n+ * +---------------------------------------------------------+\r\n+ * | |\r\n+ * 0 = readerIndex = writerIndex <= capacity\r\n+ *
\r\n+ * \r\n+ * Mark and reset
\r\n+ * \r\n+ * There are two marker indexes in every buffer. One is for storing {@link\r\n+ * #readerIndex() readerIndex} and the other is for storing {@link\r\n+ * #writerIndex() writerIndex}. You can always reposition one of the two\r\n+ * indexes by calling a reset method. It works in a similar fashion to the mark\r\n+ * and reset methods in {@link InputStream} except that there's no {@code\r\n+ * readlimit}.\r\n+ * \r\n+ * Conversion to existing JDK types
\r\n+ * \r\n+ * Byte array
\r\n+ * \r\n+ * If a {@link ChannelBuffer} is backed by a byte array (i.e. {@code byte[]}),\r\n+ * you can access it directly via the {@link #array()} method. To determine if\r\n+ * a buffer is backed by a byte array, {@link #hasArray()} should be used.\r\n+ * \r\n+ * NIO Buffers
\r\n+ * \r\n+ * Various {@link #toByteBuffer()} methods convert a {@link ChannelBuffer} into\r\n+ * one or more NIO buffers. These methods avoid buffer allocation and memory\r\n+ * copy whenever possible, but there's no guarantee that memory copy will not be\r\n+ * involved.\r\n+ * \r\n+ * I/O Streams
\r\n+ * \r\n+ * Please refer to {@link ChannelBufferInputStream} and {@link\r\n+ * ChannelBufferOutputStream}.\r\n+ *\r\n+ *\r\n+ */\r\n+public interface ChannelBuffer extends Comparable
\r\n+ *\r\n+ * @param writableBytes the expected minimum number of writable bytes\r\n+ * @throws IndexOutOfBoundsException if {@linkplain #writableBytes() the\r\n+ * writable bytes} of this buffer is less\r\n+ * than the specified value and if this\r\n+ * buffer is not a dynamic buffer\r\n+ */\r\n+ void ensureWritableBytes(int writableBytes);\r\n+\r\n+ /**\r\n+ * Determines if the content of the specified buffer is identical to the\r\n+ * content of this array. 'Identical' here means:
Please note that it\r\n+ * does not compare {@link #readerIndex()} nor {@link #writerIndex()}. This\r\n+ * method also returns {@code false} for {@code null} and an object which is\r\n+ * not an instance of {@link ChannelBuffer} type.\r\n+ */\r\n+ @Override\r\n+ boolean equals(Object o);\r\n+\r\n+ /**\r\n+ * Returns the factory which creates a {@link ChannelBuffer} whose type and\r\n+ * default {@link java.nio.ByteOrder} are same with this buffer.\r\n+ */\r\n+ ChannelBufferFactory factory();\r\n+\r\n+ /**\r\n+ * Gets a byte at the specified absolute {@code index} in this buffer. This\r\n+ * method does not modify {@code readerIndex} or {@code writerIndex} of this\r\n+ * buffer.\r\n+ *\r\n+ * @throws IndexOutOfBoundsException if the specified {@code index} is less\r\n+ * than {@code 0} or {@code index + 1} is\r\n+ * greater than {@code this.capacity}\r\n+ */\r\n+ byte getByte(int index);\r\n+\r\n+ /**\r\n+ * Transfers this buffer's data to the specified destination starting at the\r\n+ * specified absolute {@code index}. This method does not modify {@code\r\n+ * readerIndex} or {@code writerIndex} of this buffer\r\n+ *\r\n+ * @throws IndexOutOfBoundsException if the specified {@code index} is less\r\n+ * than {@code 0} or if {@code index +\r\n+ * dst.length} is greater than {@code\r\n+ * this.capacity}\r\n+ */\r\n+ void getBytes(int index, byte[] dst);\r\n+\r\n+ /**\r\n+ * Transfers this buffer's data to the specified destination starting at the\r\n+ * specified absolute {@code index}. This method does not modify {@code\r\n+ * readerIndex} or {@code writerIndex} of this buffer.\r\n+ *\r\n+ * @param dstIndex the first index of the destination\r\n+ * @param length the number of bytes to transfer\r\n+ * @throws IndexOutOfBoundsException if the specified {@code index} is less\r\n+ * than {@code 0}, if the specified {@code\r\n+ * dstIndex} is less than {@code 0}, if\r\n+ * {@code index + length} is greater than\r\n+ * {@code this.capacity}, or if {@code\r\n+ * dstIndex + length} is greater than\r\n+ * {@code dst.length}\r\n+ */\r\n+ void getBytes(int index, byte[] dst, int dstIndex, int length);\r\n+\r\n+ /**\r\n+ * Transfers this buffer's data to the specified destination starting at the\r\n+ * specified absolute {@code index} until the destination's position reaches\r\n+ * its limit. This method does not modify {@code readerIndex} or {@code\r\n+ * writerIndex} of this buffer while the destination's {@code position} will\r\n+ * be increased.\r\n+ *\r\n+ * @throws IndexOutOfBoundsException if the specified {@code index} is less\r\n+ * than {@code 0} or if {@code index +\r\n+ * dst.remaining()} is greater than {@code\r\n+ * this.capacity}\r\n+ */\r\n+ void getBytes(int index, ByteBuffer dst);\r\n+\r\n+ /**\r\n+ * Transfers this buffer's data to the specified destination starting at the\r\n+ * specified absolute {@code index} until the destination becomes\r\n+ * non-writable. This method is basically same with {@link #getBytes(int,\r\n+ * ChannelBuffer, int, int)}, except that this method increases the {@code\r\n+ * writerIndex} of the destination by the number of the transferred bytes\r\n+ * while {@link #getBytes(int, ChannelBuffer, int, int)} does not. This\r\n+ * method does not modify {@code readerIndex} or {@code writerIndex} of the\r\n+ * source buffer (i.e. {@code this}).\r\n+ *\r\n+ * @throws IndexOutOfBoundsException if the specified {@code index} is less\r\n+ * than {@code 0} or if {@code index +\r\n+ * dst.writableBytes} is greater than\r\n+ * {@code this.capacity}\r\n+ */\r\n+ void getBytes(int index, ChannelBuffer dst);\r\n+\r\n+ /**\r\n+ * Transfers this buffer's data to the specified destination starting at the\r\n+ * specified absolute {@code index}. This method is basically same with\r\n+ * {@link #getBytes(int, ChannelBuffer, int, int)}, except that this method\r\n+ * increases the {@code writerIndex} of the destination by the number of the\r\n+ * transferred bytes while {@link #getBytes(int, ChannelBuffer, int, int)}\r\n+ * does not. This method does not modify {@code readerIndex} or {@code\r\n+ * writerIndex} of the source buffer (i.e. {@code this}).\r\n+ *\r\n+ * @param length the number of bytes to transfer\r\n+ * @throws IndexOutOfBoundsException if the specified {@code index} is less\r\n+ * than {@code 0}, if {@code index +\r\n+ * length} is greater than {@code\r\n+ * this.capacity}, or if {@code length} is\r\n+ * greater than {@code dst.writableBytes}\r\n+ */\r\n+ void getBytes(int index, ChannelBuffer dst, int length);\r\n+\r\n+ /**\r\n+ * Transfers this buffer's data to the specified destination starting at the\r\n+ * specified absolute {@code index}. This method does not modify {@code\r\n+ * readerIndex} or {@code writerIndex} of both the source (i.e. {@code\r\n+ * this}) and the destination.\r\n+ *\r\n+ * @param dstIndex the first index of the destination\r\n+ * @param length the number of bytes to transfer\r\n+ * @throws IndexOutOfBoundsException if the specified {@code index} is less\r\n+ * than {@code 0}, if the specified {@code\r\n+ * dstIndex} is less than {@code 0}, if\r\n+ * {@code index + length} is greater than\r\n+ * {@code this.capacity}, or if {@code\r\n+ * dstIndex + length} is greater than\r\n+ * {@code dst.capacity}\r\n+ */\r\n+ void getBytes(int index, ChannelBuffer dst, int dstIndex, int length);\r\n+\r\n+ /**\r\n+ * Transfers this buffer's data to the specified stream starting at the\r\n+ * specified absolute {@code index}. This method does not modify {@code\r\n+ * readerIndex} or {@code writerIndex} of this buffer.\r\n+ *\r\n+ * @param length the number of bytes to transfer\r\n+ * @throws IndexOutOfBoundsException if the specified {@code index} is less\r\n+ * than {@code 0} or if {@code index +\r\n+ * length} is greater than {@code\r\n+ * this.capacity}\r\n+ * @throws IOException if the specified stream threw an\r\n+ * exception during I/O\r\n+ */\r\n+ void getBytes(int index, OutputStream dst, int length) throws IOException;\r\n+\r\n+ /**\r\n+ * Returns {@code true} if and only if this buffer is backed by an NIO\r\n+ * direct buffer.\r\n+ */\r\n+ boolean isDirect();\r\n+\r\n+ /**\r\n+ * Marks the current {@code readerIndex} in this buffer. You can reposition\r\n+ * the current {@code readerIndex} to the marked {@code readerIndex} by\r\n+ * calling {@link #resetReaderIndex()}. The initial value of the marked\r\n+ * {@code readerIndex} is {@code 0}.\r\n+ */\r\n+ void markReaderIndex();\r\n+\r\n+ /**\r\n+ * Marks the current {@code writerIndex} in this buffer. You can reposition\r\n+ * the current {@code writerIndex} to the marked {@code writerIndex} by\r\n+ * calling {@link #resetWriterIndex()}. The initial value of the marked\r\n+ * {@code writerIndex} is {@code 0}.\r\n+ */\r\n+ void markWriterIndex();\r\n+\r\n+ /**\r\n+ * Returns {@code true} if and only if {@code (this.writerIndex -\r\n+ * this.readerIndex)} is greater than {@code 0}.\r\n+ */\r\n+ boolean readable();\r\n+\r\n+ /**\r\n+ * Returns the number of readable bytes which is equal to {@code\r\n+ * (this.writerIndex - this.readerIndex)}.\r\n+ */\r\n+ int readableBytes();\r\n+\r\n+ /**\r\n+ * Gets a byte at the current {@code readerIndex} and increases the {@code\r\n+ * readerIndex} by {@code 1} in this buffer.\r\n+ *\r\n+ * @throws IndexOutOfBoundsException if {@code this.readableBytes} is less\r\n+ * than {@code 1}\r\n+ */\r\n+ byte readByte();\r\n+\r\n+ /**\r\n+ * Transfers this buffer's data to the specified destination starting at the\r\n+ * current {@code readerIndex} and increases the {@code readerIndex} by the\r\n+ * number of the transferred bytes (= {@code dst.length}).\r\n+ *\r\n+ * @throws IndexOutOfBoundsException if {@code dst.length} is greater than\r\n+ * {@code this.readableBytes}\r\n+ */\r\n+ void readBytes(byte[] dst);\r\n+\r\n+ /**\r\n+ * Transfers this buffer's data to the specified destination starting at the\r\n+ * current {@code readerIndex} and increases the {@code readerIndex} by the\r\n+ * number of the transferred bytes (= {@code length}).\r\n+ *\r\n+ * @param dstIndex the first index of the destination\r\n+ * @param length the number of bytes to transfer\r\n+ * @throws IndexOutOfBoundsException if the specified {@code dstIndex} is\r\n+ * less than {@code 0}, if {@code length}\r\n+ * is greater than {@code this.readableBytes},\r\n+ * or if {@code dstIndex + length} is\r\n+ * greater than {@code dst.length}\r\n+ */\r\n+ void readBytes(byte[] dst, int dstIndex, int length);\r\n+\r\n+ /**\r\n+ * Transfers this buffer's data to the specified destination starting at the\r\n+ * current {@code readerIndex} until the destination's position reaches its\r\n+ * limit, and increases the {@code readerIndex} by the number of the\r\n+ * transferred bytes.\r\n+ *\r\n+ * @throws IndexOutOfBoundsException if {@code dst.remaining()} is greater\r\n+ * than {@code this.readableBytes}\r\n+ */\r\n+ void readBytes(ByteBuffer dst);\r\n+\r\n+ /**\r\n+ * Transfers this buffer's data to the specified destination starting at the\r\n+ * current {@code readerIndex} until the destination becomes non-writable,\r\n+ * and increases the {@code readerIndex} by the number of the transferred\r\n+ * bytes. This method is basically same with {@link\r\n+ * #readBytes(ChannelBuffer, int, int)}, except that this method increases\r\n+ * the {@code writerIndex} of the destination by the number of the\r\n+ * transferred bytes while {@link #readBytes(ChannelBuffer, int, int)} does\r\n+ * not.\r\n+ *\r\n+ * @throws IndexOutOfBoundsException if {@code dst.writableBytes} is greater\r\n+ * than {@code this.readableBytes}\r\n+ */\r\n+ void readBytes(ChannelBuffer dst);\r\n+\r\n+ /**\r\n+ * Transfers this buffer's data to the specified destination starting at the\r\n+ * current {@code readerIndex} and increases the {@code readerIndex} by the\r\n+ * number of the transferred bytes (= {@code length}). This method is\r\n+ * basically same with {@link #readBytes(ChannelBuffer, int, int)}, except\r\n+ * that this method increases the {@code writerIndex} of the destination by\r\n+ * the number of the transferred bytes (= {@code length}) while {@link\r\n+ * #readBytes(ChannelBuffer, int, int)} does not.\r\n+ *\r\n+ * @throws IndexOutOfBoundsException if {@code length} is greater than\r\n+ * {@code this.readableBytes} or if {@code\r\n+ * length} is greater than {@code\r\n+ * dst.writableBytes}\r\n+ */\r\n+ void readBytes(ChannelBuffer dst, int length);\r\n+\r\n+ /**\r\n+ * Transfers this buffer's data to the specified destination starting at the\r\n+ * current {@code readerIndex} and increases the {@code readerIndex} by the\r\n+ * number of the transferred bytes (= {@code length}).\r\n+ *\r\n+ * @param dstIndex the first index of the destination\r\n+ * @param length the number of bytes to transfer\r\n+ * @throws IndexOutOfBoundsException if the specified {@code dstIndex} is\r\n+ * less than {@code 0}, if {@code length}\r\n+ * is greater than {@code this.readableBytes},\r\n+ * or if {@code dstIndex + length} is\r\n+ * greater than {@code dst.capacity}\r\n+ */\r\n+ void readBytes(ChannelBuffer dst, int dstIndex, int length);\r\n+\r\n+ /**\r\n+ * Transfers this buffer's data to a newly created buffer starting at the\r\n+ * current {@code readerIndex} and increases the {@code readerIndex} by the\r\n+ * number of the transferred bytes (= {@code length}). The returned buffer's\r\n+ * {@code readerIndex} and {@code writerIndex} are {@code 0} and {@code\r\n+ * length} respectively.\r\n+ *\r\n+ * @param length the number of bytes to transfer\r\n+ * @return the newly created buffer which contains the transferred bytes\r\n+ * @throws IndexOutOfBoundsException if {@code length} is greater than\r\n+ * {@code this.readableBytes}\r\n+ */\r\n+ ChannelBuffer readBytes(int length);\r\n+\r\n+ /**\r\n+ * Repositions the current {@code readerIndex} to the marked {@code\r\n+ * readerIndex} in this buffer.\r\n+ *\r\n+ * @throws IndexOutOfBoundsException if the current {@code writerIndex} is\r\n+ * less than the marked {@code\r\n+ * readerIndex}\r\n+ */\r\n+ void resetReaderIndex();\r\n+\r\n+ /**\r\n+ * Marks the current {@code writerIndex} in this buffer. You can reposition\r\n+ * the current {@code writerIndex} to the marked {@code writerIndex} by\r\n+ * calling {@link #resetWriterIndex()}. The initial value of the marked\r\n+ * {@code writerIndex} is {@code 0}.\r\n+ */\r\n+ void resetWriterIndex();\r\n+\r\n+ /**\r\n+ * Returns the {@code readerIndex} of this buffer.\r\n+ */\r\n+ int readerIndex();\r\n+\r\n+ /**\r\n+ * Sets the {@code readerIndex} of this buffer.\r\n+ *\r\n+ * @throws IndexOutOfBoundsException if the specified {@code readerIndex} is\r\n+ * less than {@code 0} or greater than\r\n+ * {@code this.writerIndex}\r\n+ */\r\n+ void readerIndex(int readerIndex);\r\n+\r\n+ /**\r\n+ * Transfers this buffer's data to the specified stream starting at the\r\n+ * current {@code readerIndex}.\r\n+ *\r\n+ * @param length the number of bytes to transfer\r\n+ * @throws IndexOutOfBoundsException if {@code length} is greater than\r\n+ * {@code this.readableBytes}\r\n+ * @throws IOException if the specified stream threw an\r\n+ * exception during I/O\r\n+ */\r\n+ void readBytes(OutputStream dst, int length) throws IOException;\r\n+\r\n+ /**\r\n+ * Sets the specified byte at the specified absolute {@code index} in this\r\n+ * buffer. The 24 high-order bits of the specified value are ignored. This\r\n+ * method does not modify {@code readerIndex} or {@code writerIndex} of this\r\n+ * buffer.\r\n+ *\r\n+ * @throws IndexOutOfBoundsException if the specified {@code index} is less\r\n+ * than {@code 0} or {@code index + 1} is\r\n+ * greater than {@code this.capacity}\r\n+ */\r\n+ void setByte(int index, int value);\r\n+\r\n+ /**\r\n+ * Transfers the specified source array's data to this buffer starting at\r\n+ * the specified absolute {@code index}. This method does not modify {@code\r\n+ * readerIndex} or {@code writerIndex} of this buffer.\r\n+ *\r\n+ * @throws IndexOutOfBoundsException if the specified {@code index} is less\r\n+ * than {@code 0} or if {@code index +\r\n+ * src.length} is greater than {@code\r\n+ * this.capacity}\r\n+ */\r\n+ void setBytes(int index, byte[] src);\r\n+\r\n+ /**\r\n+ * Transfers the specified source array's data to this buffer starting at\r\n+ * the specified absolute {@code index}. This method does not modify {@code\r\n+ * readerIndex} or {@code writerIndex} of this buffer.\r\n+ *\r\n+ * @throws IndexOutOfBoundsException if the specified {@code index} is less\r\n+ * than {@code 0}, if the specified {@code\r\n+ * srcIndex} is less than {@code 0}, if\r\n+ * {@code index + length} is greater than\r\n+ * {@code this.capacity}, or if {@code\r\n+ * srcIndex + length} is greater than\r\n+ * {@code src.length}\r\n+ */\r\n+ void setBytes(int index, byte[] src, int srcIndex, int length);\r\n+\r\n+ /**\r\n+ * Transfers the specified source buffer's data to this buffer starting at\r\n+ * the specified absolute {@code index} until the source buffer's position\r\n+ * reaches its limit. This method does not modify {@code readerIndex} or\r\n+ * {@code writerIndex} of this buffer.\r\n+ *\r\n+ * @throws IndexOutOfBoundsException if the specified {@code index} is less\r\n+ * than {@code 0} or if {@code index +\r\n+ * src.remaining()} is greater than {@code\r\n+ * this.capacity}\r\n+ */\r\n+ void setBytes(int index, ByteBuffer src);\r\n+\r\n+ /**\r\n+ * Transfers the specified source buffer's data to this buffer starting at\r\n+ * the specified absolute {@code index} until the source buffer becomes\r\n+ * unreadable. This method is basically same with {@link #setBytes(int,\r\n+ * ChannelBuffer, int, int)}, except that this method increases the {@code\r\n+ * readerIndex} of the source buffer by the number of the transferred bytes\r\n+ * while {@link #setBytes(int, ChannelBuffer, int, int)} does not. This\r\n+ * method does not modify {@code readerIndex} or {@code writerIndex} of the\r\n+ * source buffer (i.e. {@code this}).\r\n+ *\r\n+ * @throws IndexOutOfBoundsException if the specified {@code index} is less\r\n+ * than {@code 0} or if {@code index +\r\n+ * src.readableBytes} is greater than\r\n+ * {@code this.capacity}\r\n+ */\r\n+ void setBytes(int index, ChannelBuffer src);\r\n+\r\n+ /**\r\n+ * Transfers the specified source buffer's data to this buffer starting at\r\n+ * the specified absolute {@code index}. This method is basically same with\r\n+ * {@link #setBytes(int, ChannelBuffer, int, int)}, except that this method\r\n+ * increases the {@code readerIndex} of the source buffer by the number of\r\n+ * the transferred bytes while {@link #setBytes(int, ChannelBuffer, int,\r\n+ * int)} does not. This method does not modify {@code readerIndex} or {@code\r\n+ * writerIndex} of the source buffer (i.e. {@code this}).\r\n+ *\r\n+ * @param length the number of bytes to transfer\r\n+ * @throws IndexOutOfBoundsException if the specified {@code index} is less\r\n+ * than {@code 0}, if {@code index +\r\n+ * length} is greater than {@code\r\n+ * this.capacity}, or if {@code length} is\r\n+ * greater than {@code src.readableBytes}\r\n+ */\r\n+ void setBytes(int index, ChannelBuffer src, int length);\r\n+\r\n+ /**\r\n+ * Transfers the specified source buffer's data to this buffer starting at\r\n+ * the specified absolute {@code index}. This method does not modify {@code\r\n+ * readerIndex} or {@code writerIndex} of both the source (i.e. {@code\r\n+ * this}) and the destination.\r\n+ *\r\n+ * @param srcIndex the first index of the source\r\n+ * @param length the number of bytes to transfer\r\n+ * @throws IndexOutOfBoundsException if the specified {@code index} is less\r\n+ * than {@code 0}, if the specified {@code\r\n+ * srcIndex} is less than {@code 0}, if\r\n+ * {@code index + length} is greater than\r\n+ * {@code this.capacity}, or if {@code\r\n+ * srcIndex + length} is greater than\r\n+ * {@code src.capacity}\r\n+ */\r\n+ void setBytes(int index, ChannelBuffer src, int srcIndex, int length);\r\n+\r\n+ /**\r\n+ * Transfers the content of the specified source stream to this buffer\r\n+ * starting at the specified absolute {@code index}. This method does not\r\n+ * modify {@code readerIndex} or {@code writerIndex} of this buffer.\r\n+ *\r\n+ * @param length the number of bytes to transfer\r\n+ * @return the actual number of bytes read in from the specified channel.\r\n+ * {@code -1} if the specified channel is closed.\r\n+ * @throws IndexOutOfBoundsException if the specified {@code index} is less\r\n+ * than {@code 0} or if {@code index +\r\n+ * length} is greater than {@code\r\n+ * this.capacity}\r\n+ * @throws IOException if the specified stream threw an\r\n+ * exception during I/O\r\n+ */\r\n+ int setBytes(int index, InputStream src, int length) throws IOException;\r\n+\r\n+ /**\r\n+ * Sets the {@code readerIndex} and {@code writerIndex} of this buffer in\r\n+ * one shot. This method is useful when you have to worry about the\r\n+ * invocation order of {@link #readerIndex(int)} and {@link\r\n+ * #writerIndex(int)} methods. For example, the following code will fail:\r\n+ * \r\n+ * \r\n+ * // Create a buffer whose readerIndex, writerIndex and capacity are\r\n+ * // 0, 0 and 8 respectively.\r\n+ * {@link ChannelBuffer} buf = {@link ChannelBuffers}.buffer(8);\r\n+ *\r\n+ * // IndexOutOfBoundsException is thrown because the specified\r\n+ * // readerIndex (2) cannot be greater than the current writerIndex (0).\r\n+ * buf.readerIndex(2);\r\n+ * buf.writerIndex(4);\r\n+ * \r\n+ * \r\n+ * The following code will also fail:\r\n+ * \r\n+ * \r\n+ * // Create a buffer whose readerIndex, writerIndex and capacity are\r\n+ * // 0, 8 and 8 respectively.\r\n+ * {@link ChannelBuffer} buf = {@link ChannelBuffers}.wrappedBuffer(new\r\n+ * byte[8]);\r\n+ *\r\n+ * // readerIndex becomes 8.\r\n+ * buf.readLong();\r\n+ *\r\n+ * // IndexOutOfBoundsException is thrown because the specified\r\n+ * // writerIndex (4) cannot be less than the current readerIndex (8).\r\n+ * buf.writerIndex(4);\r\n+ * buf.readerIndex(2);\r\n+ * \r\n+ * \r\n+ * By contrast, {@link #setIndex(int, int)} guarantees that it never throws\r\n+ * an {@link IndexOutOfBoundsException} as long as the specified indexes\r\n+ * meet basic constraints, regardless what the current index values of the\r\n+ * buffer are:\r\n+ * \r\n+ * \r\n+ * // No matter what the current state of the buffer is, the following\r\n+ * // call always succeeds as long as the capacity of the buffer is not\r\n+ * // less than 4.\r\n+ * buf.setIndex(2, 4);\r\n+ *
\r\n+ *\r\n+ * @throws IndexOutOfBoundsException if the specified {@code readerIndex} is\r\n+ * less than 0, if the specified {@code\r\n+ * writerIndex} is less than the specified\r\n+ * {@code readerIndex} or if the specified\r\n+ * {@code writerIndex} is greater than\r\n+ * {@code this.capacity}\r\n+ */\r\n+ void setIndex(int readerIndex, int writerIndex);\r\n+\r\n+ /**\r\n+ * Increases the current {@code readerIndex} by the specified {@code length}\r\n+ * in this buffer.\r\n+ *\r\n+ * @throws IndexOutOfBoundsException if {@code length} is greater than\r\n+ * {@code this.readableBytes}\r\n+ */\r\n+ void skipBytes(int length);\r\n+\r\n+ /**\r\n+ * Converts this buffer's readable bytes into a NIO buffer. The returned\r\n+ * buffer might or might not share the content with this buffer, while they\r\n+ * have separate indexes and marks. This method is identical to {@code\r\n+ * buf.toByteBuffer(buf.readerIndex(), buf.readableBytes())}. This method\r\n+ * does not modify {@code readerIndex} or {@code writerIndex} of this\r\n+ * buffer.\r\n+ */\r\n+ ByteBuffer toByteBuffer();\r\n+\r\n+ /**\r\n+ * Converts this buffer's sub-region into a NIO buffer. The returned buffer\r\n+ * might or might not share the content with this buffer, while they have\r\n+ * separate indexes and marks. This method does not modify {@code\r\n+ * readerIndex} or {@code writerIndex} of this buffer.\r\n+ */\r\n+ ByteBuffer toByteBuffer(int index, int length);\r\n+\r\n+ /**\r\n+ * Returns {@code true} if and only if {@code (this.capacity -\r\n+ * this.writerIndex)} is greater than {@code 0}.\r\n+ */\r\n+ boolean writable();\r\n+\r\n+ /**\r\n+ * Returns the number of writable bytes which is equal to {@code\r\n+ * (this.capacity - this.writerIndex)}.\r\n+ */\r\n+ int writableBytes();\r\n+\r\n+ /**\r\n+ * Sets the specified byte at the current {@code writerIndex} and increases\r\n+ * the {@code writerIndex} by {@code 1} in this buffer. The 24 high-order\r\n+ * bits of the specified value are ignored.\r\n+ *\r\n+ * @throws IndexOutOfBoundsException if {@code this.writableBytes} is less\r\n+ * than {@code 1}\r\n+ */\r\n+ void writeByte(int value);\r\n+\r\n+ /**\r\n+ * Transfers the specified source array's data to this buffer starting at\r\n+ * the current {@code writerIndex} and increases the {@code writerIndex} by\r\n+ * the number of the transferred bytes (= {@code src.length}).\r\n+ *\r\n+ * @throws IndexOutOfBoundsException if {@code src.length} is greater than\r\n+ * {@code this.writableBytes}\r\n+ */\r\n+ void writeBytes(byte[] src);\r\n+\r\n+ /**\r\n+ * Transfers the specified source array's data to this buffer starting at\r\n+ * the current {@code writerIndex} and increases the {@code writerIndex} by\r\n+ * the number of the transferred bytes (= {@code length}).\r\n+ *\r\n+ * @param index the first index of the source\r\n+ * @param length the number of bytes to transfer\r\n+ * @throws IndexOutOfBoundsException if the specified {@code srcIndex} is\r\n+ * less than {@code 0}, if {@code srcIndex\r\n+ * + length} is greater than {@code\r\n+ * src.length}, or if {@code length} is\r\n+ * greater than {@code this.writableBytes}\r\n+ */\r\n+ void writeBytes(byte[] src, int index, int length);\r\n+\r\n+ /**\r\n+ * Transfers the specified source buffer's data to this buffer starting at\r\n+ * the current {@code writerIndex} until the source buffer's position\r\n+ * reaches its limit, and increases the {@code writerIndex} by the number of\r\n+ * the transferred bytes.\r\n+ *\r\n+ * @throws IndexOutOfBoundsException if {@code src.remaining()} is greater\r\n+ * than {@code this.writableBytes}\r\n+ */\r\n+ void writeBytes(ByteBuffer src);\r\n+\r\n+ /**\r\n+ * Transfers the specified source buffer's data to this buffer starting at\r\n+ * the current {@code writerIndex} until the source buffer becomes\r\n+ * unreadable, and increases the {@code writerIndex} by the number of the\r\n+ * transferred bytes. This method is basically same with {@link\r\n+ * #writeBytes(ChannelBuffer, int, int)}, except that this method increases\r\n+ * the {@code readerIndex} of the source buffer by the number of the\r\n+ * transferred bytes while {@link #writeBytes(ChannelBuffer, int, int)} does\r\n+ * not.\r\n+ *\r\n+ * @throws IndexOutOfBoundsException if {@code src.readableBytes} is greater\r\n+ * than {@code this.writableBytes}\r\n+ */\r\n+ void writeBytes(ChannelBuffer src);\r\n+\r\n+ /**\r\n+ * Transfers the specified source buffer's data to this buffer starting at\r\n+ * the current {@code writerIndex} and increases the {@code writerIndex} by\r\n+ * the number of the transferred bytes (= {@code length}). This method is\r\n+ * basically same with {@link #writeBytes(ChannelBuffer, int, int)}, except\r\n+ * that this method increases the {@code readerIndex} of the source buffer\r\n+ * by the number of the transferred bytes (= {@code length}) while {@link\r\n+ * #writeBytes(ChannelBuffer, int, int)} does not.\r\n+ *\r\n+ * @param length the number of bytes to transfer\r\n+ * @throws IndexOutOfBoundsException if {@code length} is greater than\r\n+ * {@code this.writableBytes} or if {@code\r\n+ * length} is greater then {@code\r\n+ * src.readableBytes}\r\n+ */\r\n+ void writeBytes(ChannelBuffer src, int length);\r\n+\r\n+ /**\r\n+ * Transfers the specified source buffer's data to this buffer starting at\r\n+ * the current {@code writerIndex} and increases the {@code writerIndex} by\r\n+ * the number of the transferred bytes (= {@code length}).\r\n+ *\r\n+ * @param srcIndex the first index of the source\r\n+ * @param length the number of bytes to transfer\r\n+ * @throws IndexOutOfBoundsException if the specified {@code srcIndex} is\r\n+ * less than {@code 0}, if {@code srcIndex\r\n+ * + length} is greater than {@code\r\n+ * src.capacity}, or if {@code length} is\r\n+ * greater than {@code this.writableBytes}\r\n+ */\r\n+ void writeBytes(ChannelBuffer src, int srcIndex, int length);\r\n+\r\n+ /**\r\n+ * Transfers the content of the specified stream to this buffer starting at\r\n+ * the current {@code writerIndex} and increases the {@code writerIndex} by\r\n+ * the number of the transferred bytes.\r\n+ *\r\n+ * @param length the number of bytes to transfer\r\n+ * @return the actual number of bytes read in from the specified stream\r\n+ * @throws IndexOutOfBoundsException if {@code length} is greater than\r\n+ * {@code this.writableBytes}\r\n+ * @throws IOException if the specified stream threw an\r\n+ * exception during I/O\r\n+ */\r\n+ int writeBytes(InputStream src, int length) throws IOException;\r\n+\r\n+ /**\r\n+ * Returns the {@code writerIndex} of this buffer.\r\n+ */\r\n+ int writerIndex();\r\n+\r\n+ /**\r\n+ * Sets the {@code writerIndex} of this buffer.\r\n+ *\r\n+ * @throws IndexOutOfBoundsException if the specified {@code writerIndex} is\r\n+ * less than {@code this.readerIndex} or\r\n+ * greater than {@code this.capacity}\r\n+ */\r\n+ void writerIndex(int writerIndex);\r\n+\r\n+ /**\r\n+ * Returns the backing byte array of this buffer.\r\n+ *\r\n+ * @throws UnsupportedOperationException if there no accessible backing byte\r\n+ * array\r\n+ */\r\n+ byte[] array();\r\n+\r\n+ /**\r\n+ * Returns {@code true} if and only if this buffer has a backing byte array.\r\n+ * If this method returns true, you can safely call {@link #array()} and\r\n+ * {@link #arrayOffset()}.\r\n+ */\r\n+ boolean hasArray();\r\n+\r\n+ /**\r\n+ * Returns the offset of the first byte within the backing byte array of\r\n+ * this buffer.\r\n+ *\r\n+ * @throws UnsupportedOperationException if there no accessible backing byte\r\n+ * array\r\n+ */\r\n+ int arrayOffset();\r\n+}\r\n"}, {"source1": "org/apache/dubbo/remoting/buffer/ChannelBuffers.java", "source2": "org/apache/dubbo/remoting/buffer/ChannelBuffers.java", "comments": ["Ordering differences only"], "unified_diff": "@@ -1,156 +1,156 @@\n-/*\n- * Licensed to the Apache Software Foundation (ASF) under one or more\n- * contributor license agreements. See the NOTICE file distributed with\n- * this work for additional information regarding copyright ownership.\n- * The ASF licenses this file to You under the Apache License, Version 2.0\n- * (the \"License\"); you may not use this file except in compliance with\n- * the License. You may obtain a copy of the License at\n- *\n- * http://www.apache.org/licenses/LICENSE-2.0\n- *\n- * Unless required by applicable law or agreed to in writing, software\n- * distributed under the License is distributed on an \"AS IS\" BASIS,\n- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n- * See the License for the specific language governing permissions and\n- * limitations under the License.\n- */\n-\n-package org.apache.dubbo.remoting.buffer;\n-\n-import java.nio.ByteBuffer;\n-\n-public final class ChannelBuffers {\n-\n- public static final ChannelBuffer EMPTY_BUFFER = new HeapChannelBuffer(0);\n-\n- private ChannelBuffers() {\n- }\n-\n- public static ChannelBuffer dynamicBuffer() {\n- return dynamicBuffer(256);\n- }\n-\n- public static ChannelBuffer dynamicBuffer(int capacity) {\n- return new DynamicChannelBuffer(capacity);\n- }\n-\n- public static ChannelBuffer dynamicBuffer(int capacity,\n- ChannelBufferFactory factory) {\n- return new DynamicChannelBuffer(capacity, factory);\n- }\n-\n- public static ChannelBuffer buffer(int capacity) {\n- if (capacity < 0) {\n- throw new IllegalArgumentException(\"capacity can not be negative\");\n- }\n- if (capacity == 0) {\n- return EMPTY_BUFFER;\n- }\n- return new HeapChannelBuffer(capacity);\n- }\n-\n- public static ChannelBuffer wrappedBuffer(byte[] array, int offset, int length) {\n- if (array == null) {\n- throw new NullPointerException(\"array == null\");\n- }\n- byte[] dest = new byte[length];\n- System.arraycopy(array, offset, dest, 0, length);\n- return wrappedBuffer(dest);\n- }\n-\n- public static ChannelBuffer wrappedBuffer(byte[] array) {\n- if (array == null) {\n- throw new NullPointerException(\"array == null\");\n- }\n- if (array.length == 0) {\n- return EMPTY_BUFFER;\n- }\n- return new HeapChannelBuffer(array);\n- }\n-\n- public static ChannelBuffer wrappedBuffer(ByteBuffer buffer) {\n- if (!buffer.hasRemaining()) {\n- return EMPTY_BUFFER;\n- }\n- if (buffer.hasArray()) {\n- return wrappedBuffer(buffer.array(), buffer.arrayOffset() + buffer.position(), buffer.remaining());\n- } else {\n- return new ByteBufferBackedChannelBuffer(buffer);\n- }\n- }\n-\n- public static ChannelBuffer directBuffer(int capacity) {\n- if (capacity == 0) {\n- return EMPTY_BUFFER;\n- }\n-\n- ChannelBuffer buffer = new ByteBufferBackedChannelBuffer(\n- ByteBuffer.allocateDirect(capacity));\n- buffer.clear();\n- return buffer;\n- }\n-\n- public static boolean equals(ChannelBuffer bufferA, ChannelBuffer bufferB) {\n- final int aLen = bufferA.readableBytes();\n- if (aLen != bufferB.readableBytes()) {\n- return false;\n- }\n-\n- final int byteCount = aLen & 7;\n-\n- int aIndex = bufferA.readerIndex();\n- int bIndex = bufferB.readerIndex();\n-\n- for (int i = byteCount; i > 0; i--) {\n- if (bufferA.getByte(aIndex) != bufferB.getByte(bIndex)) {\n- return false;\n- }\n- aIndex++;\n- bIndex++;\n- }\n-\n- return true;\n- }\n-\n- public static int hasCode(ChannelBuffer buffer){\n- final int aLen = buffer.readableBytes();\n- final int byteCount = aLen & 7;\n-\n- int hashCode = 1;\n- int arrayIndex = buffer.readerIndex();\n-\n- for (int i = byteCount; i > 0; i--) {\n- hashCode = 31 * hashCode + buffer.getByte(arrayIndex++);\n- }\n-\n- if (hashCode == 0) {\n- hashCode = 1;\n- }\n-\n- return hashCode;\n- }\n-\n- public static int compare(ChannelBuffer bufferA, ChannelBuffer bufferB) {\n- final int aLen = bufferA.readableBytes();\n- final int bLen = bufferB.readableBytes();\n- final int minLength = Math.min(aLen, bLen);\n-\n- int aIndex = bufferA.readerIndex();\n- int bIndex = bufferB.readerIndex();\n-\n- for (int i = minLength; i > 0; i--) {\n- byte va = bufferA.getByte(aIndex);\n- byte vb = bufferB.getByte(bIndex);\n- if (va > vb) {\n- return 1;\n- } else if (va < vb) {\n- return -1;\n- }\n- aIndex++;\n- bIndex++;\n- }\n-\n- return aLen - bLen;\n- }\n-\n-}\n+/*\r\n+ * Licensed to the Apache Software Foundation (ASF) under one or more\r\n+ * contributor license agreements. See the NOTICE file distributed with\r\n+ * this work for additional information regarding copyright ownership.\r\n+ * The ASF licenses this file to You under the Apache License, Version 2.0\r\n+ * (the \"License\"); you may not use this file except in compliance with\r\n+ * the License. You may obtain a copy of the License at\r\n+ *\r\n+ * http://www.apache.org/licenses/LICENSE-2.0\r\n+ *\r\n+ * Unless required by applicable law or agreed to in writing, software\r\n+ * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n+ * See the License for the specific language governing permissions and\r\n+ * limitations under the License.\r\n+ */\r\n+\r\n+package org.apache.dubbo.remoting.buffer;\r\n+\r\n+import java.nio.ByteBuffer;\r\n+\r\n+public final class ChannelBuffers {\r\n+\r\n+ public static final ChannelBuffer EMPTY_BUFFER = new HeapChannelBuffer(0);\r\n+\r\n+ private ChannelBuffers() {\r\n+ }\r\n+\r\n+ public static ChannelBuffer dynamicBuffer() {\r\n+ return dynamicBuffer(256);\r\n+ }\r\n+\r\n+ public static ChannelBuffer dynamicBuffer(int capacity) {\r\n+ return new DynamicChannelBuffer(capacity);\r\n+ }\r\n+\r\n+ public static ChannelBuffer dynamicBuffer(int capacity,\r\n+ ChannelBufferFactory factory) {\r\n+ return new DynamicChannelBuffer(capacity, factory);\r\n+ }\r\n+\r\n+ public static ChannelBuffer buffer(int capacity) {\r\n+ if (capacity < 0) {\r\n+ throw new IllegalArgumentException(\"capacity can not be negative\");\r\n+ }\r\n+ if (capacity == 0) {\r\n+ return EMPTY_BUFFER;\r\n+ }\r\n+ return new HeapChannelBuffer(capacity);\r\n+ }\r\n+\r\n+ public static ChannelBuffer wrappedBuffer(byte[] array, int offset, int length) {\r\n+ if (array == null) {\r\n+ throw new NullPointerException(\"array == null\");\r\n+ }\r\n+ byte[] dest = new byte[length];\r\n+ System.arraycopy(array, offset, dest, 0, length);\r\n+ return wrappedBuffer(dest);\r\n+ }\r\n+\r\n+ public static ChannelBuffer wrappedBuffer(byte[] array) {\r\n+ if (array == null) {\r\n+ throw new NullPointerException(\"array == null\");\r\n+ }\r\n+ if (array.length == 0) {\r\n+ return EMPTY_BUFFER;\r\n+ }\r\n+ return new HeapChannelBuffer(array);\r\n+ }\r\n+\r\n+ public static ChannelBuffer wrappedBuffer(ByteBuffer buffer) {\r\n+ if (!buffer.hasRemaining()) {\r\n+ return EMPTY_BUFFER;\r\n+ }\r\n+ if (buffer.hasArray()) {\r\n+ return wrappedBuffer(buffer.array(), buffer.arrayOffset() + buffer.position(), buffer.remaining());\r\n+ } else {\r\n+ return new ByteBufferBackedChannelBuffer(buffer);\r\n+ }\r\n+ }\r\n+\r\n+ public static ChannelBuffer directBuffer(int capacity) {\r\n+ if (capacity == 0) {\r\n+ return EMPTY_BUFFER;\r\n+ }\r\n+\r\n+ ChannelBuffer buffer = new ByteBufferBackedChannelBuffer(\r\n+ ByteBuffer.allocateDirect(capacity));\r\n+ buffer.clear();\r\n+ return buffer;\r\n+ }\r\n+\r\n+ public static boolean equals(ChannelBuffer bufferA, ChannelBuffer bufferB) {\r\n+ final int aLen = bufferA.readableBytes();\r\n+ if (aLen != bufferB.readableBytes()) {\r\n+ return false;\r\n+ }\r\n+\r\n+ final int byteCount = aLen & 7;\r\n+\r\n+ int aIndex = bufferA.readerIndex();\r\n+ int bIndex = bufferB.readerIndex();\r\n+\r\n+ for (int i = byteCount; i > 0; i--) {\r\n+ if (bufferA.getByte(aIndex) != bufferB.getByte(bIndex)) {\r\n+ return false;\r\n+ }\r\n+ aIndex++;\r\n+ bIndex++;\r\n+ }\r\n+\r\n+ return true;\r\n+ }\r\n+\r\n+ public static int hasCode(ChannelBuffer buffer){\r\n+ final int aLen = buffer.readableBytes();\r\n+ final int byteCount = aLen & 7;\r\n+\r\n+ int hashCode = 1;\r\n+ int arrayIndex = buffer.readerIndex();\r\n+\r\n+ for (int i = byteCount; i > 0; i--) {\r\n+ hashCode = 31 * hashCode + buffer.getByte(arrayIndex++);\r\n+ }\r\n+\r\n+ if (hashCode == 0) {\r\n+ hashCode = 1;\r\n+ }\r\n+\r\n+ return hashCode;\r\n+ }\r\n+\r\n+ public static int compare(ChannelBuffer bufferA, ChannelBuffer bufferB) {\r\n+ final int aLen = bufferA.readableBytes();\r\n+ final int bLen = bufferB.readableBytes();\r\n+ final int minLength = Math.min(aLen, bLen);\r\n+\r\n+ int aIndex = bufferA.readerIndex();\r\n+ int bIndex = bufferB.readerIndex();\r\n+\r\n+ for (int i = minLength; i > 0; i--) {\r\n+ byte va = bufferA.getByte(aIndex);\r\n+ byte vb = bufferB.getByte(bIndex);\r\n+ if (va > vb) {\r\n+ return 1;\r\n+ } else if (va < vb) {\r\n+ return -1;\r\n+ }\r\n+ aIndex++;\r\n+ bIndex++;\r\n+ }\r\n+\r\n+ return aLen - bLen;\r\n+ }\r\n+\r\n+}\r\n"}, {"source1": "org/apache/dubbo/remoting/exchange/Request.java", "source2": "org/apache/dubbo/remoting/exchange/Request.java", "comments": ["Ordering differences only"], "unified_diff": "@@ -1,145 +1,145 @@\n-/*\n- * Licensed to the Apache Software Foundation (ASF) under one or more\n- * contributor license agreements. See the NOTICE file distributed with\n- * this work for additional information regarding copyright ownership.\n- * The ASF licenses this file to You under the Apache License, Version 2.0\n- * (the \"License\"); you may not use this file except in compliance with\n- * the License. You may obtain a copy of the License at\n- *\n- * http://www.apache.org/licenses/LICENSE-2.0\n- *\n- * Unless required by applicable law or agreed to in writing, software\n- * distributed under the License is distributed on an \"AS IS\" BASIS,\n- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n- * See the License for the specific language governing permissions and\n- * limitations under the License.\n- */\n-package org.apache.dubbo.remoting.exchange;\n-\n-import org.apache.dubbo.common.utils.StringUtils;\n-\n-import java.util.concurrent.atomic.AtomicLong;\n-\n-import static org.apache.dubbo.common.constants.CommonConstants.HEARTBEAT_EVENT;\n-\n-/**\n- * Request.\n- */\n-public class Request {\n-\n- private static final AtomicLong INVOKE_ID = new AtomicLong(0);\n-\n- private final long mId;\n-\n- private String mVersion;\n-\n- private boolean mTwoWay = true;\n-\n- private boolean mEvent = false;\n-\n- private boolean mBroken = false;\n-\n- private Object mData;\n-\n- public Request() {\n- mId = newId();\n- }\n-\n- public Request(long id) {\n- mId = id;\n- }\n-\n- private static long newId() {\n- // getAndIncrement() When it grows to MAX_VALUE, it will grow to MIN_VALUE, and the negative can be used as ID\n- return INVOKE_ID.getAndIncrement();\n- }\n-\n- private static String safeToString(Object data) {\n- if (data == null) {\n- return null;\n- }\n- String dataStr;\n- try {\n- dataStr = data.toString();\n- } catch (Throwable e) {\n- dataStr = \"