1 /* 2 * This file is part of gtkD. 3 * 4 * gtkD is free software; you can redistribute it and/or modify 5 * it under the terms of the GNU Lesser General Public License 6 * as published by the Free Software Foundation; either version 3 7 * of the License, or (at your option) any later version, with 8 * some exceptions, please read the COPYING file. 9 * 10 * gtkD is distributed in the hope that it will be useful, 11 * but WITHOUT ANY WARRANTY; without even the implied warranty of 12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 13 * GNU Lesser General Public License for more details. 14 * 15 * You should have received a copy of the GNU Lesser General Public License 16 * along with gtkD; if not, write to the Free Software 17 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110, USA 18 */ 19 20 // generated automatically - do not change 21 // find conversion definition on APILookup.txt 22 // implement new conversion functionalities on the wrap.utils pakage 23 24 25 module gio.BufferedOutputStream; 26 27 private import gio.FilterOutputStream; 28 private import gio.OutputStream; 29 private import gio.SeekableIF; 30 private import gio.SeekableT; 31 private import glib.ConstructionException; 32 private import gobject.ObjectG; 33 private import gtkc.gio; 34 public import gtkc.giotypes; 35 36 37 /** 38 * Buffered output stream implements #GFilterOutputStream and provides 39 * for buffered writes. 40 * 41 * By default, #GBufferedOutputStream's buffer size is set at 4 kilobytes. 42 * 43 * To create a buffered output stream, use g_buffered_output_stream_new(), 44 * or g_buffered_output_stream_new_sized() to specify the buffer's size 45 * at construction. 46 * 47 * To get the size of a buffer within a buffered input stream, use 48 * g_buffered_output_stream_get_buffer_size(). To change the size of a 49 * buffered output stream's buffer, use 50 * g_buffered_output_stream_set_buffer_size(). Note that the buffer's 51 * size cannot be reduced below the size of the data within the buffer. 52 */ 53 public class BufferedOutputStream : FilterOutputStream, SeekableIF 54 { 55 /** the main Gtk struct */ 56 protected GBufferedOutputStream* gBufferedOutputStream; 57 58 /** Get the main Gtk struct */ 59 public GBufferedOutputStream* getBufferedOutputStreamStruct() 60 { 61 return gBufferedOutputStream; 62 } 63 64 /** the main Gtk struct as a void* */ 65 protected override void* getStruct() 66 { 67 return cast(void*)gBufferedOutputStream; 68 } 69 70 protected override void setStruct(GObject* obj) 71 { 72 gBufferedOutputStream = cast(GBufferedOutputStream*)obj; 73 super.setStruct(obj); 74 } 75 76 /** 77 * Sets our main struct and passes it to the parent class. 78 */ 79 public this (GBufferedOutputStream* gBufferedOutputStream, bool ownedRef = false) 80 { 81 this.gBufferedOutputStream = gBufferedOutputStream; 82 super(cast(GFilterOutputStream*)gBufferedOutputStream, ownedRef); 83 } 84 85 // add the Seekable capabilities 86 mixin SeekableT!(GBufferedOutputStream); 87 88 /** 89 */ 90 91 public static GType getType() 92 { 93 return g_buffered_output_stream_get_type(); 94 } 95 96 /** 97 * Creates a new buffered output stream for a base stream. 98 * 99 * Params: 100 * baseStream = a #GOutputStream. 101 * 102 * Return: a #GOutputStream for the given @base_stream. 103 * 104 * Throws: ConstructionException GTK+ fails to create the object. 105 */ 106 public this(OutputStream baseStream) 107 { 108 auto p = g_buffered_output_stream_new((baseStream is null) ? null : baseStream.getOutputStreamStruct()); 109 110 if(p is null) 111 { 112 throw new ConstructionException("null returned by new"); 113 } 114 115 this(cast(GBufferedOutputStream*) p, true); 116 } 117 118 /** 119 * Creates a new buffered output stream with a given buffer size. 120 * 121 * Params: 122 * baseStream = a #GOutputStream. 123 * size = a #gsize. 124 * 125 * Return: a #GOutputStream with an internal buffer set to @size. 126 * 127 * Throws: ConstructionException GTK+ fails to create the object. 128 */ 129 public this(OutputStream baseStream, size_t size) 130 { 131 auto p = g_buffered_output_stream_new_sized((baseStream is null) ? null : baseStream.getOutputStreamStruct(), size); 132 133 if(p is null) 134 { 135 throw new ConstructionException("null returned by new_sized"); 136 } 137 138 this(cast(GBufferedOutputStream*) p, true); 139 } 140 141 /** 142 * Checks if the buffer automatically grows as data is added. 143 * 144 * Return: %TRUE if the @stream's buffer automatically grows, 145 * %FALSE otherwise. 146 */ 147 public bool getAutoGrow() 148 { 149 return g_buffered_output_stream_get_auto_grow(gBufferedOutputStream) != 0; 150 } 151 152 /** 153 * Gets the size of the buffer in the @stream. 154 * 155 * Return: the current size of the buffer. 156 */ 157 public size_t getBufferSize() 158 { 159 return g_buffered_output_stream_get_buffer_size(gBufferedOutputStream); 160 } 161 162 /** 163 * Sets whether or not the @stream's buffer should automatically grow. 164 * If @auto_grow is true, then each write will just make the buffer 165 * larger, and you must manually flush the buffer to actually write out 166 * the data to the underlying stream. 167 * 168 * Params: 169 * autoGrow = a #gboolean. 170 */ 171 public void setAutoGrow(bool autoGrow) 172 { 173 g_buffered_output_stream_set_auto_grow(gBufferedOutputStream, autoGrow); 174 } 175 176 /** 177 * Sets the size of the internal buffer to @size. 178 * 179 * Params: 180 * size = a #gsize. 181 */ 182 public void setBufferSize(size_t size) 183 { 184 g_buffered_output_stream_set_buffer_size(gBufferedOutputStream, size); 185 } 186 }