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.PollableOutputStreamT; 26 27 public import gio.Cancellable; 28 public import gio.c.functions; 29 public import gio.c.types; 30 public import glib.ErrorG; 31 public import glib.GException; 32 public import glib.Source; 33 public import gtkc.giotypes; 34 35 36 /** 37 * #GPollableOutputStream is implemented by #GOutputStreams that 38 * can be polled for readiness to write. This can be used when 39 * interfacing with a non-GIO API that expects 40 * UNIX-file-descriptor-style asynchronous I/O rather than GIO-style. 41 * 42 * Since: 2.28 43 */ 44 public template PollableOutputStreamT(TStruct) 45 { 46 /** Get the main Gtk struct */ 47 public GPollableOutputStream* getPollableOutputStreamStruct(bool transferOwnership = false) 48 { 49 if (transferOwnership) 50 ownedRef = false; 51 return cast(GPollableOutputStream*)getStruct(); 52 } 53 54 55 /** 56 * Checks if @stream is actually pollable. Some classes may implement 57 * #GPollableOutputStream but have only certain instances of that 58 * class be pollable. If this method returns %FALSE, then the behavior 59 * of other #GPollableOutputStream methods is undefined. 60 * 61 * For any given stream, the value returned by this method is constant; 62 * a stream cannot switch from pollable to non-pollable or vice versa. 63 * 64 * Returns: %TRUE if @stream is pollable, %FALSE if not. 65 * 66 * Since: 2.28 67 */ 68 public bool canPoll() 69 { 70 return g_pollable_output_stream_can_poll(getPollableOutputStreamStruct()) != 0; 71 } 72 73 /** 74 * Creates a #GSource that triggers when @stream can be written, or 75 * @cancellable is triggered or an error occurs. The callback on the 76 * source is of the #GPollableSourceFunc type. 77 * 78 * As with g_pollable_output_stream_is_writable(), it is possible that 79 * the stream may not actually be writable even after the source 80 * triggers, so you should use g_pollable_output_stream_write_nonblocking() 81 * rather than g_output_stream_write() from the callback. 82 * 83 * Params: 84 * cancellable = a #GCancellable, or %NULL 85 * 86 * Returns: a new #GSource 87 * 88 * Since: 2.28 89 */ 90 public Source createSource(Cancellable cancellable) 91 { 92 auto p = g_pollable_output_stream_create_source(getPollableOutputStreamStruct(), (cancellable is null) ? null : cancellable.getCancellableStruct()); 93 94 if(p is null) 95 { 96 return null; 97 } 98 99 return new Source(cast(GSource*) p, true); 100 } 101 102 /** 103 * Checks if @stream can be written. 104 * 105 * Note that some stream types may not be able to implement this 100% 106 * reliably, and it is possible that a call to g_output_stream_write() 107 * after this returns %TRUE would still block. To guarantee 108 * non-blocking behavior, you should always use 109 * g_pollable_output_stream_write_nonblocking(), which will return a 110 * %G_IO_ERROR_WOULD_BLOCK error rather than blocking. 111 * 112 * Returns: %TRUE if @stream is writable, %FALSE if not. If an error 113 * has occurred on @stream, this will result in 114 * g_pollable_output_stream_is_writable() returning %TRUE, and the 115 * next attempt to write will return the error. 116 * 117 * Since: 2.28 118 */ 119 public bool isWritable() 120 { 121 return g_pollable_output_stream_is_writable(getPollableOutputStreamStruct()) != 0; 122 } 123 124 /** 125 * Attempts to write up to @count bytes from @buffer to @stream, as 126 * with g_output_stream_write(). If @stream is not currently writable, 127 * this will immediately return %G_IO_ERROR_WOULD_BLOCK, and you can 128 * use g_pollable_output_stream_create_source() to create a #GSource 129 * that will be triggered when @stream is writable. 130 * 131 * Note that since this method never blocks, you cannot actually 132 * use @cancellable to cancel it. However, it will return an error 133 * if @cancellable has already been cancelled when you call, which 134 * may happen if you call this method after a source triggers due 135 * to having been cancelled. 136 * 137 * Params: 138 * buffer = a buffer to write 139 * data from 140 * cancellable = a #GCancellable, or %NULL 141 * 142 * Returns: the number of bytes written, or -1 on error (including 143 * %G_IO_ERROR_WOULD_BLOCK). 144 * 145 * Throws: GException on failure. 146 */ 147 public ptrdiff_t writeNonblocking(ubyte[] buffer, Cancellable cancellable) 148 { 149 GError* err = null; 150 151 auto p = g_pollable_output_stream_write_nonblocking(getPollableOutputStreamStruct(), buffer.ptr, cast(size_t)buffer.length, (cancellable is null) ? null : cancellable.getCancellableStruct(), &err); 152 153 if (err !is null) 154 { 155 throw new GException( new ErrorG(err) ); 156 } 157 158 return p; 159 } 160 }