libs/iovm/source/IoDuration.c

   1 /*#io
   2 Duration ioDoc(
   3                         docCopyright("Steve Dekorte", 2002)
   4                         docLicense("BSD revised")
   5                         docDescription("A container for a duration of time.")
   6                         docCategory("Time")
   7 */
   8
   9 #include "IoDuration.h"
  10 #include "IoState.h"
  11 #include "IoCFunction.h"
  12 #include "IoObject.h"
  13 #include "IoNumber.h"
  14 #include <time.h>
  15
  16 #define DATA(self) ((Duration *)IoObject_dataPointer(self))
  17
  18 // extend message object
  19
  20 IoDuration *IoMessage_locals_durationArgAt_(IoMessage *self, void *locals, int n)
  21 {
  22         IoObject *v = IoMessage_locals_valueArgAt_(self, (IoObject *)locals, n);
  23         if (!ISDURATION(v)) IoMessage_locals_numberArgAt_errorForType_(self, (IoObject *)locals, n, "Duration");
  24         return v;
  25 }
  26
  27 // ---------------------------------------------
  28
  29 typedef struct tm tm;
  30
  31 IoTag *IoDuration_newTag(void *state)
  32 {
  33         IoTag *tag = IoTag_newWithName_("Duration");
  34         IoTag_state_(tag, state);
  35         IoTag_cloneFunc_(tag, (IoTagCloneFunc *)IoDuration_rawClone);
  36         IoTag_freeFunc_(tag, (IoTagFreeFunc *)IoDuration_free);
  37         IoTag_compareFunc_(tag, (IoTagCompareFunc *)IoDuration_compare);
  38         IoTag_writeToStreamFunc_(tag, (IoTagWriteToStreamFunc *)IoDuration_writeToStream_);
  39         IoTag_readFromStreamFunc_(tag, (IoTagReadFromStreamFunc *)IoDuration_readFromStream_);
  40         return tag;
  41 }
  42
  43 void IoDuration_writeToStream_(IoDuration *self, BStream *stream)
  44 {
  45         BStream_writeTaggedDouble_(stream, Duration_asSeconds(DATA(self)));
  46 }
  47
  48 void IoDuration_readFromStream_(IoDuration *self, BStream *stream)
  49 {
  50         Duration_fromSeconds_(DATA(self), BStream_readTaggedDouble(stream));
  51 }
  52
  53 IoDuration *IoDuration_proto(void *state)
  54 {
  55         IoMethodTable methodTable[] = {
  56         {"years", IoDuration_years},
  57         {"setYears", IoDuration_setYears},
  58         {"days", IoDuration_days},
  59         {"setDays", IoDuration_setDays},
  60         {"hours", IoDuration_hours},
  61         {"setHours", IoDuration_setHours},
  62         {"minutes", IoDuration_minutes},
  63         {"setMinutes", IoDuration_setMinutes},
  64         {"seconds", IoDuration_seconds},
  65         {"setSeconds", IoDuration_setSeconds},
  66         {"totalSeconds", IoDuration_asNumber},
  67
  68         {"asString", IoDuration_asString},
  69         {"asNumber", IoDuration_asNumber},
  70
  71         {"fromNumber", IoDuration_fromNumber},
  72         /*Tag_addMethod(tag, "fromString", IoDuration_fromString),*/
  73
  74         {"print", IoDuration_printDuration},
  75         {"+=", IoDuration_add},
  76         {"-=", IoDuration_subtract},
  77         {NULL, NULL},
  78         };
  79
  80
  81         IoObject *self = IoObject_new(state);
  82
  83         IoObject_setDataPointer_(self, Duration_new());
  84         IoObject_tag_(self, IoDuration_newTag(state));
  85         IoState_registerProtoWithFunc_((IoState *)state, self, IoDuration_proto);
  86
  87         IoObject_addMethodTable_(self, methodTable);
  88         return self;
  89 }
  90
  91 IoDuration *IoDuration_rawClone(IoDuration *proto)
  92 {
  93         IoObject *self = IoObject_rawClonePrimitive(proto);
  94         IoObject_setDataPointer_(self, Duration_new());
  95         Duration_copy_(DATA(self), DATA(proto));
  96         return self;
  97 }
  98
  99 IoDuration *IoDuration_new(void *state)
 100 {
 101         IoDuration *proto = IoState_protoWithInitFunction_((IoState *)state, IoDuration_proto);
 102         return IOCLONE(proto);
 103 }
 104
 105 IoDuration *IoDuration_newWithSeconds_(void *state, double s)
 106 {
 107         IoDuration *self = IoDuration_new(state);
 108         IoDuration_fromSeconds_(self, s);
 109         return self;
 110 }
 111
 112 int IoDuration_compare(IoDuration *self, IoDuration *other)
 113 {
 114         if (ISDURATION(other))
 115         {
 116         return Duration_compare(DATA(self), DATA(other));
 117         }
 118
 119         return IoObject_defaultCompare(self, other);
 120 }
 121
 122 void IoDuration_free(IoDuration *self)
 123 {
 124         Duration_free(DATA(self));
 125 }
 126
 127 Duration *IoDuration_duration(IoDuration *self)
 128 {
 129         return DATA(self);
 130 }
 131
 132 IoDuration *IoDuration_fromSeconds_(IoDuration *self, double s)
 133 {
 134         Duration_fromSeconds_(DATA(self), s);
 135         return self;
 136 }
 137
 138 double IoDuration_asSeconds(IoDuration *self)
 139 {
 140         return Duration_asSeconds(DATA(self));
 141 }
 142
 143 // years --------------------------------------------------------
 144
 145 IoObject *IoDuration_years(IoDuration *self, IoObject *locals, IoMessage *m)
 146 {
 147         /*#io
 148         docSlot("years", "Returns a number containing the year of the receiver. ")
 149         */
 150
 151         return IONUMBER(Duration_years(DATA(self)));
 152 }
 153
 154 IoObject *IoDuration_setYears(IoDuration *self, IoObject *locals, IoMessage *m)
 155 {
 156         /*#io
 157         docSlot("setYears(aNumber)", "Sets the year of the receiver. Returns self.")
 158         */
 159
 160         Duration_setYears_(DATA(self), IoMessage_locals_doubleArgAt_(m, locals, 0));
 161         return self;
 162 }
 163
 164 // days --------------------------------------------------------
 165
 166 IoObject *IoDuration_days(IoDuration *self, IoObject *locals, IoMessage *m)
 167 {
 168         /*#io
 169         docSlot("days",
 170         "Returns a number containing the day of the month of the receiver. ")
 171         */
 172
 173         return IONUMBER(Duration_days(DATA(self)));
 174 }
 175
 176 IoObject *IoDuration_setDays(IoDuration *self, IoObject *locals, IoMessage *m)
 177 {
 178         /*#io
 179         docSlot("setDays(aNumber)", "Sets the day of the receiver. Returns self.")
 180         */
 181
 182         Duration_setDays_(DATA(self), IoMessage_locals_doubleArgAt_(m, locals, 0));
 183         return self;
 184 }
 185
 186 // hours --------------------------------------------------------
 187
 188 IoObject *IoDuration_hours(IoDuration *self, IoObject *locals, IoMessage *m)
 189 {
 190         /*#io
 191         docSlot("hours",
 192         "Returns a number containing the hour of the day(0-23) of the receiver. ")
 193         */
 194
 195         return IONUMBER(Duration_hours(DATA(self)));
 196 }
 197
 198 IoObject *IoDuration_setHours(IoDuration *self, IoObject *locals, IoMessage *m)
 199 {
 200         /*#io
 201         docSlot("setHours(aNumber)", "Sets the hour of the receiver. Returns self.")
 202         */
 203
 204         Duration_setHours_(DATA(self), IoMessage_locals_doubleArgAt_(m, locals, 0));
 205         return self;
 206 }
 207
 208 // minutes --------------------------------------------------------
 209
 210 IoObject *IoDuration_minutes(IoDuration *self, IoObject *locals, IoMessage *m)
 211 {
 212         /*#io
 213         docSlot("minutes",
 214         "Returns a number containing the minute of the hour(0-59) of the receiver. ")
 215         */
 216
 217         return IONUMBER(Duration_minutes(DATA(self)));
 218 }
 219
 220 IoObject *IoDuration_setMinutes(IoDuration *self, IoObject *locals, IoMessage *m)
 221 {
 222         /*#io
 223         docSlot("setMinutes(aNumber)",
 224         "Sets the minute of the receiver. Returns self.")
 225         */
 226
 227         Duration_setMinutes_(DATA(self), IoMessage_locals_doubleArgAt_(m, locals, 0));
 228         return self;
 229 }
 230
 231 // seconds --------------------------------------------------------
 232
 233 IoObject *IoDuration_seconds(IoDuration *self, IoObject *locals, IoMessage *m)
 234 {
 235         /*#io
 236         docSlot("seconds",
 237         "Returns a number containing the seconds of the minute(0-59) of the receiver.
 238         This number may contain fractions of seconds. ")
 239         */
 240
 241         return IONUMBER(Duration_seconds(DATA(self)));
 242 }
 243
 244 IoObject *IoDuration_setSeconds(IoDuration *self, IoObject *locals, IoMessage *m)
 245 {
 246         /*#io
 247         docSlot("setSeconds(aNumber)",
 248         "Sets the second of the receiver. Return self.")
 249         */
 250
 251         Duration_setSeconds_(DATA(self), IoMessage_locals_doubleArgAt_(m, locals, 0));
 252         return self;
 253 }
 254
 255 // conversion --------------------------------------------------------
 256
 257 IoObject *IoDuration_asString(IoDuration *self, IoObject *locals, IoMessage *m)
 258 {
 259         /*#io
 260         docSlot("asString(formatString)",
 261         """Returns a string representation of the receiver. The formatString argument is optional. If present, the returned string will be formatted according to ANSI C date formating rules.
 262
 263         <pre>
 264         %y years without century as two-digit decimal number (00-99)
 265         %Y year with century as four-digit decimal number
 266
 267         %d days
 268         %H hour as two-digit 24-hour clock decimal integer (00-23)
 269         %M minute as a two-digit decimal integer (00-59)
 270         %S second as a two-digit decimal integer (00-59)
 271
 272         The default format is "%Y %d %H:%M:%S".
 273         """)
 274         */
 275         UArray *ba;
 276         char *format = NULL;
 277
 278         if (IoMessage_argCount(m) == 1)
 279         {
 280         format = CSTRING(IoMessage_locals_symbolArgAt_(m, locals, 0));
 281         }
 282
 283         ba = Duration_asUArrayWithFormat_(DATA(self), format);
 284         return IoState_symbolWithUArray_copy_(IOSTATE, ba, 0);
 285 }
 286
 287 IoObject *IoDuration_printDuration(IoDuration *self, IoObject *locals, IoMessage *m)
 288 {
 289         /*#io
 290         docSlot("print", "Prints the receiver. Returns self.")
 291         */
 292
 293         Duration_print(DATA(self));
 294         return self;
 295 }
 296
 297         /*#io
 298         docSlot("totalSeconds",
 299         "Same as a asNumber.")
 300         */
 301
 302 IoObject *IoDuration_asNumber(IoDuration *self, IoObject *locals, IoMessage *m)
 303 {
 304         /*#io
 305         docSlot("asNumber",
 306         "Returns a number representation of the receiver.
 307         (where 1 is equal to one second) ")
 308         */
 309
 310         return IONUMBER(Duration_asSeconds(DATA(self)));
 311 }
 312
 313 IoObject *IoDuration_fromNumber(IoDuration *self, IoObject *locals, IoMessage *m)
 314 {
 315         /*#io
 316         docSlot("fromNumber(aNumber)",
 317         "Sets the receiver to the Duration specified by
 318         aNumber(same format number as returned by Duration asNumber). Returns self. ")
 319         */
 320
 321         Duration_fromSeconds_(DATA(self), IoMessage_locals_doubleArgAt_(m, locals, 0));
 322         return self;
 323 }
 324
 325 // math --------------------------------------------------------
 326
 327 IoObject *IoDuration_add(IoDuration *self, IoObject *locals, IoMessage *m)
 328 {
 329         /*#io
 330         docSlot("+=(aDuration)", "Add aDuration to the receiver. Returns self. ")
 331         */
 332
 333         IoDuration *d = IoMessage_locals_durationArgAt_(m, locals, 0);
 334         Duration_add_(DATA(self), DATA(d));
 335         return self;
 336 }
 337
 338 IoObject *IoDuration_subtract(IoDuration *self, IoObject *locals, IoMessage *m)
 339 {
 340         /*#io
 341         docSlot("-=(aDuration)", "Subtract aDuration to the receiver. Returns self. ")
 342         */
 343
 344         IoDuration *d = IoMessage_locals_durationArgAt_(m, locals, 0);
 345         Duration_subtract_(DATA(self), DATA(d));
 346         return self;
 347 }
 348