--- /dev/null
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+/**
+ * Transports which operate on generic D ranges.
+ */
+module thrift.transport.range;
+
+import std.array : empty;
+import std.range;
+import std.traits : Unqual;
+import thrift.transport.base;
+
+/**
+ * Adapts an ubyte input range for reading via the TTransport interface.
+ *
+ * The case where R is a plain ubyte[] is reasonably optimized, so a possible
+ * use case for TInputRangeTransport would be to deserialize some data held in
+ * a memory buffer.
+ */
+final class TInputRangeTransport(R) if (
+ isInputRange!(Unqual!R) && is(ElementType!R : const(ubyte))
+) : TBaseTransport {
+ /**
+ * Constructs a new instance.
+ *
+ * Params:
+ * data = The input range to use as data.
+ */
+ this(R data) {
+ data_ = data;
+ }
+
+ /**
+ * An input range transport is always open.
+ */
+ override bool isOpen() @property {
+ return true;
+ }
+
+ override bool peek() {
+ return !data_.empty;
+ }
+
+ /**
+ * Opening is a no-op() for an input range transport.
+ */
+ override void open() {}
+
+ /**
+ * Closing is a no-op() for a memory buffer.
+ */
+ override void close() {}
+
+ override size_t read(ubyte[] buf) {
+ auto data = data_.take(buf.length);
+ auto bytes = data.length;
+
+ static if (is(typeof(R.init[1 .. 2]) : const(ubyte)[])) {
+ // put() is currently unnecessarily slow if both ranges are sliceable.
+ buf[0 .. bytes] = data[];
+ data_ = data_[bytes .. $];
+ } else {
+ buf.put(data);
+ }
+
+ return bytes;
+ }
+
+ /**
+ * Shortcut version of readAll() for slicable ranges.
+ *
+ * Because readAll() is typically a very hot path during deserialization,
+ * using this over TBaseTransport.readAll() gives us a nice increase in
+ * speed due to the reduced amount of indirections.
+ */
+ override void readAll(ubyte[] buf) {
+ static if (is(typeof(R.init[1 .. 2]) : const(ubyte)[])) {
+ if (buf.length <= data_.length) {
+ buf[] = data_[0 .. buf.length];
+ data_ = data_[buf.length .. $];
+ return;
+ }
+ }
+ super.readAll(buf);
+ }
+
+ override const(ubyte)[] borrow(ubyte* buf, size_t len) {
+ static if (is(R : const(ubyte)[])) {
+ // Can only borrow if our data type is actually an ubyte array.
+ if (len <= data_.length) {
+ return data_;
+ }
+ }
+ return null;
+ }
+
+ override void consume(size_t len) {
+ static if (is(R : const(ubyte)[])) {
+ if (len > data_.length) {
+ throw new TTransportException("Invalid consume length",
+ TTransportException.Type.BAD_ARGS);
+ }
+ data_ = data_[len .. $];
+ } else {
+ super.consume(len);
+ }
+ }
+
+ /**
+ * Sets a new data range to use.
+ */
+ void reset(R data) {
+ data_ = data;
+ }
+
+private:
+ R data_;
+}
+
+/**
+ * TInputRangeTransport construction helper to avoid having to explicitly
+ * specify the argument type, i.e. to allow the constructor being called using
+ * IFTI (see $(LINK2 http://d.puremagic.com/issues/show_bug.cgi?id=6082, D
+ * Bugzilla enhancement requet 6082)).
+ */
+TInputRangeTransport!R tInputRangeTransport(R)(R data) if (
+ is (TInputRangeTransport!R)
+) {
+ return new TInputRangeTransport!R(data);
+}