ThreadPipe

Conduit to support a data stream between 2 threads. One creates a ThreadPipe, then uses the OutputStream and the InputStream from it to communicate. All traffic is automatically synchronized, so one just uses the streams like they were normal device streams.

It works by maintaining a circular buffer, where data is written to, and read from, in a FIFO fashion.

auto tc = new ThreadPipe;
void outFunc()
{
  Stdout.copy(tc.input);
}

auto t = new Thread(&outFunc);
t.start();
tc.write("hello, thread!");
tc.close();
t.join();

class ThreadPipe : Conduit {

this(size_t bufferSize);

size_t bufferSize();

string toString();

bool isAlive();

size_t remaining();

size_t writable();

void stop();

void detach();

size_t read(void[] dst);

ThreadPipe clear();

size_t write(const(void)[] src);

}

Constructors

this this(size_t bufferSize): Create a new ThreadPipe with the given buffer size.

Members

Functions

bufferSize size_t bufferSize(): Implements IConduit.bufferSize.
clear ThreadPipe clear(): Implements InputStream.clear().
detach void detach(): This does nothing because we have no clue whether the members have been collected, and detach is run in the destructor. To stop communications, use stop().
isAlive bool isAlive(): Returns true if there is data left to be read, and the write end isn't closed.
read size_t read(void[] dst): Implements InputStream.read.
remaining size_t remaining(): Return the number of bytes remaining to be read in the circular buffer.
stop void stop(): Close the write end of the conduit. Writing to the conduit after it is closed will return Eof.
toString string toString(): Implements IConduit.toString
writable size_t writable(): Return the number of bytes that can be written to the circular buffer.
write size_t write(const(void)[] src): Implements OutputStream.write.

Inherited Members

From Conduit

scheduler Fiber.Scheduler scheduler;: Undocumented in source.
~this ~this(): Clean up when collected. See method detach().
toString string toString(): Return the name of this conduit.
bufferSize size_t bufferSize(): Return a preferred size for buffering conduit I/O.
read size_t read(void[] dst): Read from conduit into a target array. The provided dst will be populated with content from the conduit.
write size_t write(const(void)[] src): Write to conduit from a source array. The provided src content will be written to the conduit.
detach void detach(): Disconnect this conduit. Note that this may be invoked both explicitly by the user, and implicitly by the GC. Be sure to manage multiple detachment requests correctly: set a flag, or sentinel value as necessary.
timeout uint timeout [@property setter]: Set the active timeout period for IO calls (in milliseconds.)
timeout uint timeout [@property getter]: Get the active timeout period for IO calls (in milliseconds.)
isAlive bool isAlive [@property getter]: Is the conduit alive? Default behaviour returns true.
conduit IConduit conduit [@property getter]: Return the host. This is part of the Stream interface.
flush IOStream flush(): Emit buffered output or reset buffered input.
close void close(): Close this conduit.
error void error(const(char[]) msg): Throw an IOException, with the provided message.
input InputStream input [@property getter]: Return the input stream.
output OutputStream output [@property getter]: Return the output stream.
put Conduit put(void[] src): Emit fixed-length content from 'src' into this conduit, throwing an IOException upon Eof.
get Conduit get(void[] dst): Consume fixed-length content into 'dst' from this conduit, throwing an IOException upon Eof.
rewind Conduit rewind(): Rewind to beginning of file.
copy OutputStream copy(InputStream src, size_t max): Transfer the content of another conduit to this one. Returns the dst OutputStream, or throws IOException on failure.
seek long seek(long offset, Anchor anchor): Seek on this stream. Source conduits that don't support seeking will throw an IOException.
text char[] text(size_t max): Load text from a stream, and return them all in an array.
load void[] load(size_t max): Load the bits from a stream, and return them all in an array. The dst array can be provided as an option, which will be expanded as necessary to consume the input.
load void[] load(InputStream src, size_t max): Load the bits from a stream, and return them all in an array. The dst array can be provided as an option, which will be expanded as necessary to consume input.
put void put(void[] src, OutputStream output): Emit fixed-length content from 'src' into 'output', throwing an IOException upon Eof.
get void get(void[] dst, InputStream input): Consume fixed-length content into 'dst' from 'input', throwing an IOException upon Eof.
transfer size_t transfer(InputStream src, OutputStream dst, size_t max): Low-level data transfer, where max represents the maximum number of bytes to transfer.