1 /* Fo
2  * fo-integer.c: Integer datatype
3  *
4  * Copyright (C) 2001 Sun Microsystems
5  * Copyright (C) 2007 Menteith Consulting Ltd
6  *
7  * See COPYING for the status of this software.
8  */
9 
10 #include "fo-utils.h"
11 #include "fo-object.h"
12 #include "fo-datatype.h"
13 #include "fo-datatype-private.h"
14 #include "fo-numeric.h"
15 #include "fo-number.h"
16 #include "fo-integer.h"
17 
18 
19 enum {
20   PROP_0,
21   PROP_VALUE
22 };
23 
24 struct _FoInteger
25 {
26   FoDatatype parent_instance;
27 
28   gint value;
29 };
30 
31 struct _FoIntegerClass
32 {
33   FoDatatypeClass parent_class;
34 
35 };
36 
37 static void fo_integer_init         (FoInteger      *integer);
38 static void fo_integer_class_init   (FoIntegerClass *klass);
39 static void fo_integer_set_property (GObject        *object,
40 				     guint           prop_id,
41 				     const GValue   *value,
42 				     GParamSpec     *pspec);
43 static void fo_integer_get_property (GObject        *object,
44 				     guint           prop_id,
45 				     GValue         *value,
46 				     GParamSpec     *pspec);
47 static void fo_integer_finalize     (GObject        *object);
48 
49 static FoDatatype* fo_integer_copy         (FoDatatype     *datatype);
50 static gchar*      fo_integer_sprintf      (FoObject       *object);
51 static void fo_integer_set_value    (FoDatatype     *integer,
52 				     gint            new_value);
53 
54 static gpointer parent_class;
55 
56 /**
57  * fo_integer_get_type:
58  * @void:
59  *
60  * Register the #FoInteger object type.
61  *
62  * Return value: GType value of the #FoInteger object type.
63  **/
64 GType
fo_integer_get_type(void)65 fo_integer_get_type (void)
66 {
67   static GType object_type = 0;
68 
69   if (!object_type)
70     {
71       static const GTypeInfo object_info =
72       {
73         sizeof (FoIntegerClass),
74         (GBaseInitFunc) NULL,
75         (GBaseFinalizeFunc) NULL,
76         (GClassInitFunc) fo_integer_class_init,
77         NULL,           /* class_finalize */
78         NULL,           /* class_data */
79         sizeof (FoInteger),
80         0,              /* n_preallocs */
81         (GInstanceInitFunc) fo_integer_init,
82 	NULL		/* value_table */
83       };
84 
85       object_type = g_type_register_static (FO_TYPE_DATATYPE,
86                                             "FoInteger",
87                                             &object_info, 0);
88     }
89 
90   return object_type;
91 }
92 
93 /**
94  * fo_integer_init:
95  * @integer: #FoInteger object to initialise
96  *
97  * Implements GInstanceInitFunc for #FoInteger
98  **/
99 void
fo_integer_init(FoInteger * integer)100 fo_integer_init (FoInteger *integer)
101 {
102   integer->value = 0;
103 }
104 
105 /**
106  * fo_integer_class_init:
107  * @klass: FoIntegerClass object to initialise
108  *
109  * Implements GClassInitFunc for FoIntegerClass
110  **/
111 void
fo_integer_class_init(FoIntegerClass * klass)112 fo_integer_class_init (FoIntegerClass *klass)
113 {
114   GObjectClass *object_class = G_OBJECT_CLASS (klass);
115 
116   parent_class = g_type_class_peek_parent (klass);
117 
118   object_class->finalize = fo_integer_finalize;
119 
120   object_class->set_property = fo_integer_set_property;
121   object_class->get_property = fo_integer_get_property;
122 
123   FO_OBJECT_CLASS (klass)->print_sprintf = fo_integer_sprintf;
124 
125   FO_DATATYPE_CLASS (klass)->copy = fo_integer_copy;
126 
127   g_object_class_install_property (object_class,
128                                    PROP_VALUE,
129                                    g_param_spec_int ("value",
130 						     _("Value"),
131 						     _("Integer value"),
132 						     G_MININT,
133 						     G_MAXINT,
134 						     0,
135 						     G_PARAM_READWRITE |
136 						     G_PARAM_CONSTRUCT_ONLY));
137 }
138 
139 /**
140  * fo_integer_finalize:
141  * @object: FoInteger object to finalize
142  *
143  * Implements GObjectFinalizeFunc for FoInteger
144  **/
145 void
fo_integer_finalize(GObject * object)146 fo_integer_finalize (GObject *object)
147 {
148   FoInteger *integer;
149 
150   integer = FO_INTEGER (object);
151 
152   G_OBJECT_CLASS (parent_class)->finalize (object);
153 }
154 
155 
156 /**
157  * fo_integer_set_property:
158  * @object:  GObject whose property will be set
159  * @prop_id: Property ID assigned when property registered
160  * @value:   New value for property
161  * @pspec:   Parameter specification for this property type
162  *
163  * Implements #GObjectSetPropertyFunc for FoInteger
164  **/
165 void
fo_integer_set_property(GObject * object,guint prop_id,const GValue * value,GParamSpec * pspec)166 fo_integer_set_property (GObject         *object,
167                          guint            prop_id,
168                          const GValue    *value,
169                          GParamSpec      *pspec)
170 {
171   FoDatatype *integer;
172 
173   integer = FO_DATATYPE (object);
174 
175   switch (prop_id)
176     {
177     case PROP_VALUE:
178       fo_integer_set_value (integer, g_value_get_int (value));
179       break;
180     default:
181       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
182       break;
183     }
184 }
185 
186 /**
187  * fo_integer_get_property:
188  * @object:  GObject whose property will be retreived
189  * @prop_id: Property ID assigned when property registered
190  * @value:   GValue to set with property value
191  * @pspec:   Parameter specification for this property type
192  *
193  * Implements #GObjectGetPropertyFunc for FoInteger
194  **/
195 void
fo_integer_get_property(GObject * object,guint prop_id,GValue * value,GParamSpec * pspec)196 fo_integer_get_property (GObject         *object,
197                          guint            prop_id,
198                          GValue          *value,
199                          GParamSpec      *pspec)
200 {
201   FoDatatype *integer;
202 
203   integer = FO_DATATYPE (object);
204 
205   switch (prop_id)
206     {
207     case PROP_VALUE:
208       g_value_set_int (value, fo_integer_get_value (integer));
209       break;
210     default:
211       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
212       break;
213     }
214 }
215 
216 /**
217  * fo_integer_new:
218  *
219  * Creates a new #FoInteger initialized to default value.
220  *
221  * Return value: the new #FoInteger.
222  **/
223 FoDatatype *
fo_integer_new(void)224 fo_integer_new (void)
225 {
226   FoDatatype *integer;
227 
228   integer = FO_DATATYPE (g_object_new (fo_integer_get_type (), NULL));
229 
230   return integer;
231 }
232 
233 /**
234  * fo_integer_new_with_value:
235  * @value: Value of the new #FoInteger.
236  *
237  * Creates a new #FoInteger set to @value.
238  *
239  * Return value: The new #FoInteger.
240  **/
241 FoDatatype*
fo_integer_new_with_value(gint value)242 fo_integer_new_with_value (gint value)
243 {
244   FoDatatype *integer = fo_integer_new ();
245 
246   fo_integer_set_value (integer, value);
247 
248   return integer;
249 }
250 
251 /**
252  * fo_integer_get_value:
253  * @integer: #FoInteger.
254  *
255  * Get the value of @integer.
256  *
257  * Return value: Numeric value of @integer.
258  **/
259 gint
fo_integer_get_value(FoDatatype * integer)260 fo_integer_get_value (FoDatatype *integer)
261 {
262   g_return_val_if_fail (integer != NULL, 0);
263   g_return_val_if_fail (FO_IS_INTEGER (integer) || FO_IS_NUMBER (integer), 0);
264 
265   if (FO_IS_INTEGER (integer))
266     {
267       return FO_INTEGER (integer)->value;
268     }
269   else
270     {
271       return ((int) fo_number_get_value (integer));
272     }
273 }
274 
275 /**
276  * fo_integer_set_value:
277  * @integer:    #FoInteger.
278  * @new_value: New value for @integer.
279  *
280  * Set the value of @integer.
281  **/
282 void
fo_integer_set_value(FoDatatype * integer,gint new_value)283 fo_integer_set_value (FoDatatype *integer,
284 		      gint        new_value)
285 {
286   g_return_if_fail (integer != NULL);
287   g_return_if_fail (FO_IS_INTEGER (integer));
288 
289   FO_INTEGER (integer)->value = new_value;
290   /*g_object_notify(G_OBJECT(integer), "value");*/
291 }
292 
293 /**
294  * fo_integer_copy:
295  * @datatype: #FoInteger to be copied.
296  *
297  * Create a copy of @datatype.
298  *
299  * Return value: New #FoInteger.
300  **/
301 FoDatatype*
fo_integer_copy(FoDatatype * datatype)302 fo_integer_copy(FoDatatype *datatype)
303 {
304   FoDatatype* integer;
305 
306   g_return_val_if_fail (datatype != NULL, NULL);
307   g_return_val_if_fail (FO_IS_INTEGER (datatype), NULL);
308 
309   integer = fo_integer_new ();
310   FO_INTEGER (integer)->value = FO_INTEGER (datatype)->value;
311 
312   return (integer);
313 }
314 
315 /**
316  * fo_integer_sprintf:
317  * @object: #FoInteger to be printed.
318  *
319  * Creates string representation of value of @object.
320  *
321  * String must be freed by caller.
322  *
323  * Return value: String representation of @object.
324  **/
325 gchar*
fo_integer_sprintf(FoObject * object)326 fo_integer_sprintf (FoObject *object)
327 {
328   g_return_val_if_fail (object != NULL, NULL);
329   g_return_val_if_fail (FO_IS_INTEGER (object), NULL);
330 
331   return (g_strdup_printf("%0d", FO_INTEGER (object)->value));
332 }
333 
334 /**
335  * fo_integer_get_integer_zero:
336  *
337  * Create and return an #FoInteger with the well-known value 0.
338  *
339  * This saves creation of multiple #FoInteger objects that all have the
340  * value 0.
341  *
342  * Return value: #FoInteger with value 0.
343  **/
344 FoDatatype*
fo_integer_get_integer_zero(void)345 fo_integer_get_integer_zero (void)
346 {
347   static FoDatatype *integer = NULL;
348 
349   if (!integer)
350     {
351       integer = fo_integer_new ();
352       FO_INTEGER (integer)->value = 0;
353     }
354 
355   return integer;
356 }
357 
358 /**
359  * fo_integer_get_integer_one:
360  *
361  * Create and return an #FoInteger with the well-known value 1.
362  *
363  * This saves creation of multiple #FoInteger objects that all have the
364  * value 1.
365  *
366  * Return value: #FoInteger with value 1.
367  **/
368 FoDatatype*
fo_integer_get_integer_one(void)369 fo_integer_get_integer_one (void)
370 {
371   static FoDatatype *integer = NULL;
372 
373   if (!integer)
374     {
375       integer = fo_integer_new ();
376       FO_INTEGER (integer)->value = 1;
377     }
378 
379   return integer;
380 }
381 
382 /**
383  * fo_integer_get_integer_two:
384  *
385  * Create and return an #FoInteger with the well-known value 2.
386  *
387  * This saves creation of multiple #FoInteger objects that all have the
388  * value 2.
389  *
390  * Return value: #FoInteger with value 2.
391  **/
392 FoDatatype*
fo_integer_get_integer_two(void)393 fo_integer_get_integer_two (void)
394 {
395   static FoDatatype *integer = NULL;
396 
397   if (!integer)
398     {
399       integer = fo_integer_new ();
400       FO_INTEGER (integer)->value = 2;
401     }
402 
403   return integer;
404 }
405 
406 /**
407  * fo_integer_get_integer_three:
408  *
409  * Create and return an #FoInteger with the well-known value 3.
410  *
411  * This saves creation of multiple #FoInteger objects that all have the
412  * value 3.
413  *
414  * Return value: #FoInteger with value 3.
415  **/
416 FoDatatype*
fo_integer_get_integer_three(void)417 fo_integer_get_integer_three (void)
418 {
419   static FoDatatype *integer = NULL;
420 
421   if (!integer)
422     {
423       integer = fo_integer_new ();
424       FO_INTEGER (integer)->value = 3;
425     }
426 
427   return integer;
428 }
429 
430 /**
431  * fo_integer_get_integer_four:
432  *
433  * Create and return an #FoInteger with the well-known value 4.
434  *
435  * This saves creation of multiple #FoInteger objects that all have the
436  * value 4.
437  *
438  * Return value: #FoInteger with value 4.
439  **/
440 FoDatatype*
fo_integer_get_integer_four(void)441 fo_integer_get_integer_four (void)
442 {
443   static FoDatatype *integer = NULL;
444 
445   if (!integer)
446     {
447       integer = fo_integer_new ();
448       FO_INTEGER (integer)->value = 4;
449     }
450 
451   return integer;
452 }
453 
454 /**
455  * fo_integer_get_integer_five:
456  *
457  * Create and return an #FoInteger with the well-known value 5.
458  *
459  * This saves creation of multiple #FoInteger objects that all have the
460  * value 5.
461  *
462  * Return value: #FoInteger with value 5.
463  **/
464 FoDatatype*
fo_integer_get_integer_five(void)465 fo_integer_get_integer_five (void)
466 {
467   static FoDatatype *integer = NULL;
468 
469   if (!integer)
470     {
471       integer = fo_integer_new ();
472       FO_INTEGER (integer)->value = 5;
473     }
474 
475   return integer;
476 }
477 
478 /**
479  * fo_integer_get_integer_six:
480  *
481  * Create and return an #FoInteger with the well-known value 6.
482  *
483  * This saves creation of multiple #FoInteger objects that all have the
484  * value 6.
485  *
486  * Return value: #FoInteger with value 6.
487  **/
488 FoDatatype*
fo_integer_get_integer_six(void)489 fo_integer_get_integer_six (void)
490 {
491   static FoDatatype *integer = NULL;
492 
493   if (!integer)
494     {
495       integer = fo_integer_new ();
496       FO_INTEGER (integer)->value = 6;
497     }
498 
499   return integer;
500 }
501