Mercurial > projects > ldc

comparison tango/tango/io/protocol/model/IWriter.d @ 132:1700239cab2e trunk

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
[svn r136] MAJOR UNSTABLE UPDATE!!! Initial commit after moving to Tango instead of Phobos. Lots of bugfixes... This build is not suitable for most things.
author lindquist
date Fri, 11 Jan 2008 17:57:40 +0100
parents
children
comparison
equal deleted inserted replaced
131:5825d48b27d1 132:1700239cab2e
1 /*******************************************************************************
2
3 copyright: Copyright (c) 2004 Kris Bell. All rights reserved
4
5 license: BSD style: $(LICENSE)
6
7 version: Mar 2004: Initial release
8 Dec 2006: Outback release
9
10 author: Kris
11 Ivan Senji (the "alias put" idea)
12
13 *******************************************************************************/
14
15 module tango.io.protocol.model.IWriter;
16
17 public import tango.io.model.IBuffer;
18
19 /*******************************************************************************
20
21 IWriter interface. Writers provide the means to append formatted
22 data to an IBuffer, and expose a convenient method of handling a
23 variety of data types. In addition to writing native types such
24 as integer and char[], writers also process any class which has
25 implemented the IWritable interface (one method).
26
27 All writers support the full set of native data types, plus their
28 fundamental array variants. Operations may be chained back-to-back.
29
30 Writers support a Java-esque put() notation. However, the Tango style
31 is to place IO elements within their own parenthesis, like so:
32
33 ---
34 write (count) (" green bottles");
35 ---
36
37 Note that each written element is distict; this style is affectionately
38 known as "whisper". The code below illustrates basic operation upon a
39 memory buffer:
40
41 ---
42 auto buf = new Buffer (256);
43
44 // map same buffer into both reader and writer
45 auto read = new Reader (buf);
46 auto write = new Writer (buf);
47
48 int i = 10;
49 long j = 20;
50 double d = 3.14159;
51 char[] c = "fred";
52
53 // write data types out
54 write (c) (i) (j) (d);
55
56 // read them back again
57 read (c) (i) (j) (d);
58
59
60 // same thing again, but using put() syntax instead
61 write.put(c).put(i).put(j).put(d);
62 read.get(c).get(i).get(j).get(d);
63
64 ---
65
66 Writers may also be used with any class implementing the IWritable
67 interface, along with any struct implementing an equivalent function.
68
69 *******************************************************************************/
70
71 abstract class IWriter // could be an interface, but that causes poor codegen
72 {
73 alias put opCall;
74
75 /***********************************************************************
76
77 These are the basic writer methods
78
79 ***********************************************************************/
80
81 abstract IWriter put (bool x);
82 abstract IWriter put (ubyte x); ///ditto
83 abstract IWriter put (byte x); ///ditto
84 abstract IWriter put (ushort x); ///ditto
85 abstract IWriter put (short x); ///ditto
86 abstract IWriter put (uint x); ///ditto
87 abstract IWriter put (int x); ///ditto
88 abstract IWriter put (ulong x); ///ditto
89 abstract IWriter put (long x); ///ditto
90 abstract IWriter put (float x); ///ditto
91 abstract IWriter put (double x); ///ditto
92 abstract IWriter put (real x); ///ditto
93 abstract IWriter put (char x); ///ditto
94 abstract IWriter put (wchar x); ///ditto
95 abstract IWriter put (dchar x); ///ditto
96
97 abstract IWriter put (bool[] x);
98 abstract IWriter put (byte[] x); ///ditto
99 abstract IWriter put (short[] x); ///ditto
100 abstract IWriter put (int[] x); ///ditto
101 abstract IWriter put (long[] x); ///ditto
102 abstract IWriter put (ubyte[] x); ///ditto
103 abstract IWriter put (ushort[] x); ///ditto
104 abstract IWriter put (uint[] x); ///ditto
105 abstract IWriter put (ulong[] x); ///ditto
106 abstract IWriter put (float[] x); ///ditto
107 abstract IWriter put (double[] x); ///ditto
108 abstract IWriter put (real[] x); ///ditto
109 abstract IWriter put (char[] x); ///ditto
110 abstract IWriter put (wchar[] x); ///ditto
111 abstract IWriter put (dchar[] x); ///ditto
112
113 /***********************************************************************
114
115 This is the mechanism used for binding arbitrary classes
116 to the IO system. If a class implements IWritable, it can
117 be used as a target for IWriter put() operations. That is,
118 implementing IWritable is intended to transform any class
119 into an IWriter adaptor for the content held therein
120
121 ***********************************************************************/
122
123 abstract IWriter put (IWritable);
124
125 alias void delegate (IWriter) Closure;
126
127 abstract IWriter put (Closure);
128
129 /***********************************************************************
130
131 Emit a newline
132
133 ***********************************************************************/
134
135 abstract IWriter newline ();
136
137 /***********************************************************************
138
139 Flush the output of this writer. Throws an IOException
140 if the operation fails. These are aliases for each other
141
142 ***********************************************************************/
143
144 abstract IWriter flush ();
145 abstract IWriter put (); ///ditto
146
147 /***********************************************************************
148
149 Return the associated buffer
150
151 ***********************************************************************/
152
153 abstract IBuffer buffer ();
154 }
155
156
157 /*******************************************************************************
158
159 Interface to make any class compatible with any IWriter
160
161 *******************************************************************************/
162
163 interface IWritable
164 {
165 abstract void write (IWriter input);
166 }
167