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 glib.RandG;
26 
27 private import glib.ConstructionException;
28 private import glib.c.functions;
29 public  import glib.c.types;
30 public  import gtkc.glibtypes;
31 private import gtkd.Loader;
32 
33 
34 /**
35  * The GRand struct is an opaque data structure. It should only be
36  * accessed through the g_rand_* functions.
37  */
38 public class RandG
39 {
40 	/** the main Gtk struct */
41 	protected GRand* gRand;
42 	protected bool ownedRef;
43 
44 	/** Get the main Gtk struct */
45 	public GRand* getRandGStruct(bool transferOwnership = false)
46 	{
47 		if (transferOwnership)
48 			ownedRef = false;
49 		return gRand;
50 	}
51 
52 	/** the main Gtk struct as a void* */
53 	protected void* getStruct()
54 	{
55 		return cast(void*)gRand;
56 	}
57 
58 	/**
59 	 * Sets our main struct and passes it to the parent class.
60 	 */
61 	public this (GRand* gRand, bool ownedRef = false)
62 	{
63 		this.gRand = gRand;
64 		this.ownedRef = ownedRef;
65 	}
66 
67 	~this ()
68 	{
69 		if ( Linker.isLoaded(LIBRARY_GLIB) && ownedRef )
70 			g_rand_free(gRand);
71 	}
72 
73 
74 	/**
75 	 * Copies a #GRand into a new one with the same exact state as before.
76 	 * This way you can take a snapshot of the random number generator for
77 	 * replaying later.
78 	 *
79 	 * Returns: the new #GRand
80 	 *
81 	 * Since: 2.4
82 	 */
83 	public RandG copy()
84 	{
85 		auto p = g_rand_copy(gRand);
86 
87 		if(p is null)
88 		{
89 			return null;
90 		}
91 
92 		return new RandG(cast(GRand*) p);
93 	}
94 
95 	/**
96 	 * Returns the next random #gdouble from @rand_ equally distributed over
97 	 * the range [0..1).
98 	 *
99 	 * Returns: a random number
100 	 */
101 	public double randDouble()
102 	{
103 		return g_rand_double(gRand);
104 	}
105 
106 	/**
107 	 * Returns the next random #gdouble from @rand_ equally distributed over
108 	 * the range [@begin..@end).
109 	 *
110 	 * Params:
111 	 *     begin = lower closed bound of the interval
112 	 *     end = upper open bound of the interval
113 	 *
114 	 * Returns: a random number
115 	 */
116 	public double doubleRange(double begin, double end)
117 	{
118 		return g_rand_double_range(gRand, begin, end);
119 	}
120 
121 	/**
122 	 * Frees the memory allocated for the #GRand.
123 	 */
124 	public void free()
125 	{
126 		g_rand_free(gRand);
127 		ownedRef = false;
128 	}
129 
130 	/**
131 	 * Returns the next random #guint32 from @rand_ equally distributed over
132 	 * the range [0..2^32-1].
133 	 *
134 	 * Returns: a random number
135 	 */
136 	public uint randInt()
137 	{
138 		return g_rand_int(gRand);
139 	}
140 
141 	/**
142 	 * Returns the next random #gint32 from @rand_ equally distributed over
143 	 * the range [@begin..@end-1].
144 	 *
145 	 * Params:
146 	 *     begin = lower closed bound of the interval
147 	 *     end = upper open bound of the interval
148 	 *
149 	 * Returns: a random number
150 	 */
151 	public int intRange(int begin, int end)
152 	{
153 		return g_rand_int_range(gRand, begin, end);
154 	}
155 
156 	/**
157 	 * Sets the seed for the random number generator #GRand to @seed.
158 	 *
159 	 * Params:
160 	 *     seed = a value to reinitialize the random number generator
161 	 */
162 	public void setSeed(uint seed)
163 	{
164 		g_rand_set_seed(gRand, seed);
165 	}
166 
167 	/**
168 	 * Initializes the random number generator by an array of longs.
169 	 * Array can be of arbitrary size, though only the first 624 values
170 	 * are taken.  This function is useful if you have many low entropy
171 	 * seeds, or if you require more then 32 bits of actual entropy for
172 	 * your application.
173 	 *
174 	 * Params:
175 	 *     seed = array to initialize with
176 	 *     seedLength = length of array
177 	 *
178 	 * Since: 2.4
179 	 */
180 	public void setSeedArray(uint* seed, uint seedLength)
181 	{
182 		g_rand_set_seed_array(gRand, seed, seedLength);
183 	}
184 
185 	/**
186 	 * Creates a new random number generator initialized with a seed taken
187 	 * either from `/dev/urandom` (if existing) or from the current time
188 	 * (as a fallback).
189 	 *
190 	 * On Windows, the seed is taken from rand_s().
191 	 *
192 	 * Returns: the new #GRand
193 	 *
194 	 * Throws: ConstructionException GTK+ fails to create the object.
195 	 */
196 	public this()
197 	{
198 		auto p = g_rand_new();
199 
200 		if(p is null)
201 		{
202 			throw new ConstructionException("null returned by new");
203 		}
204 
205 		this(cast(GRand*) p);
206 	}
207 
208 	/**
209 	 * Creates a new random number generator initialized with @seed.
210 	 *
211 	 * Params:
212 	 *     seed = a value to initialize the random number generator
213 	 *
214 	 * Returns: the new #GRand
215 	 *
216 	 * Throws: ConstructionException GTK+ fails to create the object.
217 	 */
218 	public this(uint seed)
219 	{
220 		auto p = g_rand_new_with_seed(seed);
221 
222 		if(p is null)
223 		{
224 			throw new ConstructionException("null returned by new_with_seed");
225 		}
226 
227 		this(cast(GRand*) p);
228 	}
229 
230 	/**
231 	 * Creates a new random number generator initialized with @seed.
232 	 *
233 	 * Params:
234 	 *     seed = an array of seeds to initialize the random number generator
235 	 *
236 	 * Returns: the new #GRand
237 	 *
238 	 * Since: 2.4
239 	 *
240 	 * Throws: ConstructionException GTK+ fails to create the object.
241 	 */
242 	public this(uint[] seed)
243 	{
244 		auto p = g_rand_new_with_seed_array(seed.ptr, cast(uint)seed.length);
245 
246 		if(p is null)
247 		{
248 			throw new ConstructionException("null returned by new_with_seed_array");
249 		}
250 
251 		this(cast(GRand*) p);
252 	}
253 
254 	/**
255 	 * Returns a random #gdouble equally distributed over the range [0..1).
256 	 *
257 	 * Returns: a random number
258 	 */
259 	public static double randomDouble()
260 	{
261 		return g_random_double();
262 	}
263 
264 	/**
265 	 * Returns a random #gdouble equally distributed over the range
266 	 * [@begin..@end).
267 	 *
268 	 * Params:
269 	 *     begin = lower closed bound of the interval
270 	 *     end = upper open bound of the interval
271 	 *
272 	 * Returns: a random number
273 	 */
274 	public static double randomDoubleRange(double begin, double end)
275 	{
276 		return g_random_double_range(begin, end);
277 	}
278 
279 	/**
280 	 * Return a random #guint32 equally distributed over the range
281 	 * [0..2^32-1].
282 	 *
283 	 * Returns: a random number
284 	 */
285 	public static uint randomInt()
286 	{
287 		return g_random_int();
288 	}
289 
290 	/**
291 	 * Returns a random #gint32 equally distributed over the range
292 	 * [@begin..@end-1].
293 	 *
294 	 * Params:
295 	 *     begin = lower closed bound of the interval
296 	 *     end = upper open bound of the interval
297 	 *
298 	 * Returns: a random number
299 	 */
300 	public static int randomIntRange(int begin, int end)
301 	{
302 		return g_random_int_range(begin, end);
303 	}
304 
305 	/**
306 	 * Sets the seed for the global random number generator, which is used
307 	 * by the g_random_* functions, to @seed.
308 	 *
309 	 * Params:
310 	 *     seed = a value to reinitialize the global random number generator
311 	 */
312 	public static void randomSetSeed(uint seed)
313 	{
314 		g_random_set_seed(seed);
315 	}
316 }