Changeset 25026 for trunk

Show
Ignore:
Timestamp:
02/08/10 21:20:10 (7 months ago)
Author:
piotras
Message:

Initial commit for MidgardTimestamp? rewrite.
Simplify boxed type values implementation. Improve memory management.

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • trunk/midgard/core/midgard/src/midgard_metadata.c

    r24841 r25026  
    4141 
    4242        if (person)  
    43                 person_guid = (gchar *)MGD_OBJECT_GUID(person);                  
    44  
    45         GValue *tval = midgard_timestamp_new_current(); 
     43                person_guid = (gchar *)MGD_OBJECT_GUID (person);                         
    4644         
    4745        /* set creator */ 
    48         midgard_core_metadata_set_creator(mdata, person_guid); 
    49  
    50         /* set created */       
    51         midgard_core_metadata_set_created(mdata, tval); 
     46        midgard_core_metadata_set_creator (mdata, person_guid); 
     47 
     48        /* set created */ 
     49        midgard_core_timestamp_set_current_time (mdata->priv->created);         
    5250 
    5351        /* set revised */        
    54         midgard_core_metadata_set_revised(mdata, tval); 
     52        midgard_core_timestamp_set_current_time (mdata->priv->revised); 
    5553 
    5654        /* set revision */ 
    57         midgard_core_metadata_set_revision(mdata, 0); 
     55        midgard_core_metadata_set_revision (mdata, 0); 
    5856 
    5957        /* set revisor */ 
    60         midgard_core_metadata_set_revisor(mdata, person_guid); 
    61          
    62         g_value_unset(tval); 
    63         g_free (tval);  
     58        midgard_core_metadata_set_revisor (mdata, person_guid); 
    6459} 
    6560 
    …… 
    7570                person_guid = (gchar *)MGD_OBJECT_GUID(person);                  
    7671 
    77         GValue *tval = midgard_timestamp_new_current(); 
    78  
    7972        /* set revisor */ 
    8073        midgard_core_metadata_set_revisor(mdata, person_guid); 
    8174 
    8275        /* set revised */ 
    83         midgard_core_metadata_set_revised(mdata, tval); 
     76        midgard_core_timestamp_set_current_time (mdata->priv->revised); 
    8477 
    8578        /* set revision */ 
    86         midgard_core_metadata_increase_revision(mdata); 
    87          
    88         g_value_unset(tval);     
    89         g_free (tval); 
     79        midgard_core_metadata_increase_revision (mdata); 
    9080} 
    9181 
    …… 
    9888{ 
    9989        MidgardMetadata *mdata = (MidgardMetadata *) ud;         
    100         GValue *tval = midgard_timestamp_new_current(); 
    101  
    102         /* set imported */ 
    103         midgard_core_metadata_set_imported (mdata, tval); 
    104          
    105         g_value_unset (tval); 
    106         g_free (tval); 
     90        midgard_core_timestamp_set_current_time (mdata->priv->imported); 
    10791} 
    10892 
    …… 
    116100         * touched by new API */ 
    117101        if (!mdata->priv->revised && !mdata->priv->created) { 
    118                 midgard_core_metadata_set_created(mdata, tval); 
    119                 midgard_core_metadata_set_revised(mdata, tval); 
     102                midgard_core_timestamp_set_current_time (mdata->priv->created); 
     103                midgard_core_timestamp_set_current_time (mdata->priv->revised); 
    120104        } 
    121105 
    122106        if (!mdata->priv->revised && mdata->priv->created) { 
    123                 midgard_core_metadata_set_created(mdata, tval); 
     107                midgard_core_timestamp_set_current_time (mdata->priv->created); 
    124108                midgard_core_metadata_increase_revision(mdata); 
    125109        } 
    126110 
    127111        if (!mdata->priv->created && mdata->priv->revised) { 
    128                 midgard_core_metadata_set_created(mdata, tval); 
     112                midgard_core_timestamp_set_current_time (mdata->priv->created); 
    129113        } 
    130114                 
    131115        /* set exported */ 
    132         midgard_core_metadata_set_exported(mdata, tval); 
     116        midgard_core_timestamp_set_current_time (mdata->priv->exported); 
    133117 
    134118        g_value_unset ((GValue *)tval); 
    …… 
    395379        self->priv = g_new(MidgardMetadataPrivate, 1); 
    396380        self->priv->creator = NULL; 
    397         self->priv->created = NULL; 
    398         self->priv->revised = NULL; 
     381        self->priv->created = midgard_timestamp_new(); 
     382        self->priv->revised = midgard_timestamp_new(); 
    399383        self->priv->revisor = NULL; 
    400384        self->priv->locker = NULL; 
    401         self->priv->locked = NULL; 
    402         self->priv->approved = NULL; 
     385        self->priv->locked = midgard_timestamp_new(); 
     386        self->priv->approved = midgard_timestamp_new(); 
    403387        self->priv->approver = NULL; 
    404388        self->priv->authors = NULL; 
    405389        self->priv->owner = NULL; 
    406390        self->priv->revision = 0; 
    407         self->priv->schedule_start = NULL; 
    408         self->priv->schedule_end = NULL; 
     391        self->priv->schedule_start = midgard_timestamp_new(); 
     392        self->priv->schedule_end = midgard_timestamp_new(); 
    409393        self->priv->hidden = FALSE; 
    410394        self->priv->nav_noentry = FALSE; 
    411395        self->priv->size = 0; 
    412         self->priv->published = NULL; 
     396        self->priv->published = midgard_timestamp_new(); 
    413397        self->priv->score = 0; 
    414         self->priv->exported = NULL; 
    415         self->priv->imported = NULL; 
     398        self->priv->exported = midgard_timestamp_new(); 
     399        self->priv->imported = midgard_timestamp_new(); 
    416400        self->priv->deleted = FALSE; 
    417401 
    …… 
    942926        klass->dbpriv->storage_data = type_attr; 
    943927        klass->dbpriv->set_from_xml_node = __set_from_xml_node; 
     928        klass->dbpriv->has_metadata = FALSE; 
    944929} 
    945930 
    …… 
    1013998} 
    1014999 
    1015 void __set_date_from_node(xmlNode *node,  MidgardTimestamp **date) 
     1000void __set_date_from_node (xmlNode *node, MidgardTimestamp **date) 
     1001{ 
     1002        if (!node) 
     1003                return; 
     1004 
     1005        gchar *content = NULL; 
     1006        content = (gchar *)xmlNodeGetContent (node); 
     1007 
     1008        if (content == NULL) { 
     1009                g_warning ("Can not handle NULL date for datetime property"); 
     1010                return; 
     1011        } 
     1012 
     1013        if (*date != NULL) 
     1014                g_free (*date); 
     1015 
     1016        *date = midgard_timestamp_new_from_iso8601 (content); 
     1017        xmlFree (content); 
     1018         
     1019        return; 
     1020} 
     1021 
     1022gint __get_node_content_int(xmlNode *node) 
    10161023{ 
    10171024        if(!node) 
    1018                 return; 
     1025                return 0; 
    10191026 
    10201027        gchar *content = NULL; 
    10211028        content = (gchar *)xmlNodeGetContent(node); 
    10221029 
    1023         if (content == NULL) { 
    1024                 g_warning("Can not handle NULL date for datetime property"); 
    1025                 return; 
    1026         } 
    1027  
    1028         if (*date != NULL) 
    1029                 g_free(*date); 
    1030  
    1031         *date = midgard_timestamp_new_from_iso8601(content); 
    1032          
    1033         return; 
    1034 } 
    1035  
    1036 gint __get_node_content_int(xmlNode *node) 
     1030        if(content == NULL) 
     1031                return 0; 
     1032 
     1033        gint rv = (gint)atoi((gchar *)content); 
     1034 
     1035        g_free(content); 
     1036 
     1037        return rv; 
     1038} 
     1039 
     1040guint __get_node_content_uint(xmlNode *node) 
    10371041{ 
    10381042        if(!node) 
    …… 
    10451049                return 0; 
    10461050 
    1047         gint rv = (gint)atoi((gchar *)content); 
     1051        guint rv = (guint)atoi((gchar *)content); 
    10481052 
    10491053        g_free(content); 
    …… 
    10521056} 
    10531057 
    1054 guint __get_node_content_uint(xmlNode *node) 
     1058gboolean __get_node_content_bool(xmlNode *node) 
    10551059{ 
    10561060        if(!node) 
    1057                 return 0; 
     1061                return FALSE; 
    10581062 
    10591063        gchar *content = NULL; 
    …… 
    10631067                return 0; 
    10641068 
    1065         guint rv = (guint)atoi((gchar *)content); 
    1066  
    1067         g_free(content); 
    1068  
    1069         return rv; 
    1070 } 
    1071  
    1072 gboolean __get_node_content_bool(xmlNode *node) 
    1073 { 
    1074         if(!node) 
    1075                 return FALSE; 
    1076  
    1077         gchar *content = NULL; 
    1078         content = (gchar *)xmlNodeGetContent(node); 
    1079  
    1080         if(content == NULL) 
    1081                 return 0; 
    1082  
    10831069        gboolean rv = (gboolean)atoi((gchar *)content); 
    10841070 

  • trunk/midgard/core/midgard/src/midgard_object.c

    r25005 r25026  
    196196        MidgardObject *self = (MidgardObject *) object; 
    197197        MidgardConnection *mgd = MGD_OBJECT_CNC (MIDGARD_DBOBJECT (object)); 
     198        GValue *pval; 
    198199 
    199200        if (midgard_core_object_property_refuse_private (mgd, priv, MIDGARD_DBOBJECT (object), pspec->name)) 
    …… 
    216217                                                prop_id_local < priv->num_properties)) { 
    217218                                if (priv->num_properties) { 
    218                                         if (priv->properties && G_IS_VALUE( 
    219                                                                 &priv->properties[prop_id_local]->value)) { 
    220                                                 g_value_copy(&priv->properties[prop_id_local]->value,  
    221                                                                 value); 
     219                                        if (priv->properties) { 
     220                                                pval = &priv->properties[prop_id_local]->value; 
     221                                                if (G_IS_VALUE (pval)) {         
     222                                                        g_value_copy(pval, value);                       
     223                                                } else { 
     224                                                        /* Initialize Midgardtimestamp. 
     225                                                         * There's no need to do it in constructor. Just do it when it's really needed */ 
     226                                                        if (G_VALUE_TYPE (value) == MGD_TYPE_TIMESTAMP) {                                
     227                                                                MidgardTimestamp *mt = midgard_timestamp_new (); 
     228                                                                g_value_init (pval, MGD_TYPE_TIMESTAMP); 
     229                                                                g_value_take_boxed (pval, mt); 
     230                                                                g_value_copy (pval, value); 
     231                                                        } 
     232                                                } 
    222233                                        } 
    223234                                } 
    …… 
    24142425        g_value_init (&tval, MGD_TYPE_TIMESTAMP); 
    24152426        midgard_timestamp_set_current_time(&tval); 
    2416         const gchar *timeupdated = midgard_timestamp_get_string_from_value (&tval); 
     2427        gchar *timeupdated = midgard_timestamp_get_string_from_value (&tval); 
    24172428        object->metadata->priv->revision++; 
    24182429        g_string_append_printf(sql, 
    …… 
    24242435 
    24252436        g_string_append_printf(sql, " WHERE guid = '%s' ",  MGD_OBJECT_GUID(object)); 
    2426  
    24272437        gint qr = midgard_core_query_execute(MGD_OBJECT_CNC (object), sql->str, FALSE); 
     2438 
    24282439        g_string_free(sql, TRUE); 
     2440        g_free (timeupdated); 
    24292441         
    24302442        if (qr == 0) { 
    …… 
    29672979        } 
    29682980 
     2981        if (midgard_object_is_approved(self)) { 
     2982 
     2983                g_warning("Object is already approved"); 
     2984                return FALSE; 
     2985        } 
     2986 
    29692987        /* approved time value */ 
    29702988        GValue *tval = midgard_timestamp_new_current(); 
    …… 
    29893007        g_value_init (&stval, GDA_TYPE_TIMESTAMP); 
    29903008        g_value_transform (tval, &stval); 
    2991  
    2992         if (midgard_object_is_approved(self)) { 
    2993  
    2994                 g_warning("Object is already approved"); 
    2995                 return FALSE; 
    2996         } 
    29973009 
    29983010        gboolean rv = midgard_core_query_update_object_fields( 
    …… 
    30123024                self->metadata->priv->is_approved = TRUE; 
    30133025                 
    3014                 midgard_core_metadata_set_approved(self->metadata, tval); 
    3015                 self->metadata->priv->approver = g_value_dup_string(&gval); 
    3016                 self->metadata->priv->revisor = g_value_dup_string(&gval); 
    3017                 midgard_core_metadata_set_revised(self->metadata, tval); 
    3018                 self->metadata->priv->revision = g_value_get_uint(&rval); 
     3026                midgard_core_metadata_set_approved (self->metadata, tval); 
     3027                midgard_core_metadata_set_approver (self->metadata, g_value_get_string (&gval)); 
     3028                midgard_core_metadata_set_revisor (self->metadata, g_value_get_string (&gval)); 
     3029                midgard_core_metadata_set_revised (self->metadata, tval); 
     3030                self->metadata->priv->revision = g_value_get_uint (&rval); 
    30193031        } 
    30203032 
    …… 
    32503262        } 
    32513263 
     3264        if (midgard_object_is_locked(self)) { 
     3265 
     3266                g_warning("Object is already locked"); 
     3267                MIDGARD_ERRNO_SET(mgd, MGD_ERR_OBJECT_IS_LOCKED); 
     3268                g_object_unref(self); 
     3269                return FALSE; 
     3270        } 
     3271 
    32523272        /* approved time value */ 
    32533273        GValue *tval = midgard_timestamp_new_current(); 
    …… 
    32783298        g_value_transform (tval, &stval); 
    32793299 
    3280         if (midgard_object_is_locked(self)) { 
    3281  
    3282                 g_warning("Object is already locked"); 
    3283                 MIDGARD_ERRNO_SET(mgd, MGD_ERR_OBJECT_IS_LOCKED); 
    3284                 g_object_unref(self); 
    3285                 return FALSE; 
    3286         } 
    3287          
    32883300        gboolean rv = midgard_core_query_update_object_fields( 
    32893301                        MIDGARD_DBOBJECT(self),  

  • trunk/midgard/core/midgard/src/midgard_timestamp.c

    r24402 r25026  
    158158} 
    159159 
     160static void  
     161__timestamp_struct_reset (MidgardTimestamp *ct)  
     162{ 
     163        g_return_if_fail (ct != NULL); 
     164 
     165        guint64 u = ct->date_value + 58486; 
     166        long s = u % 86400ULL; 
     167        long day = u / 86400ULL - 53375995543064ULL; 
     168        long year = day / 146097L; 
     169        long month; 
     170        //int yday;  
     171 
     172        ct->second = s % 60; s /= 60; 
     173        ct->minute = s % 60; s /= 60; 
     174        ct->hour = s; 
     175 
     176        day = (day % 146097L) + 678881L; 
     177        while (day >= 146097L) { day -= 146097L; ++year; } 
     178 
     179        // year * 146097 + day - 678881 is MJD; 0 <= day < 146097  
     180        // 2000-03-01, MJD 51604, is year 5, day 0  
     181 
     182        year *= 4; 
     183        if (day == 146096L) { year += 3; day = 36524L; } 
     184        else { year += day / 36524L; day %= 36524L; } 
     185        year = year * 25 + day / 1461; 
     186        day %= 1461; 
     187        year *= 4; 
     188 
     189        if (day == 1460) { year += 3; day = 365; } 
     190        else { year += day / 365; day %= 365; } 
     191 
     192        day *= 10; 
     193        month = (day + 5) / 306; 
     194        day = (day + 5) % 306; 
     195        day /= 10; 
     196         
     197        if (month >= 10) { ++year; month -= 10; } 
     198        else { month += 2; } 
     199 
     200        ct->year = year; 
     201        ct->month = month + 1; 
     202        ct->day = day + 1; 
     203         
     204        ct->offset = 0;  
     205} 
     206 
    160207static void midgard_timestamp_set(MidgardTimestamp *ct)  
    161208{ 
    …… 
    238285} 
    239286 
    240 /* Internal initialization function for the midgard_timestamp value type. */ 
    241 static void value_init_timestamp(GValue *value)  
    242 { 
    243         g_assert(G_VALUE_HOLDS(value, MIDGARD_TYPE_TIMESTAMP)); 
    244  
    245         MidgardTimestamp *mt = midgard_timestamp_new(); 
    246         g_value_take_boxed(value, mt); 
    247 } 
    248  
    249287/* Internal copy function for the midgard_timestamp value type. */ 
    250 static void value_copy_timestamp(const GValue *src, GValue *dst)  
    251 { 
    252         g_assert(G_VALUE_HOLDS(src, MIDGARD_TYPE_TIMESTAMP)); 
    253         g_assert(G_VALUE_HOLDS(dst, MIDGARD_TYPE_TIMESTAMP)); 
     288gpointer 
     289__midgard_timestamp_copy (gpointer boxed)  
     290{ 
     291        MidgardTimestamp *src = (MidgardTimestamp *) boxed; 
     292        //g_assert (G_VALUE_HOLDS (src, MIDGARD_TYPE_TIMESTAMP)); 
    254293 
    255294        MidgardTimestamp *mt = midgard_timestamp_new();  
    256295 
    257         MidgardTimestamp *mtsrc = (MidgardTimestamp *) g_value_get_boxed(src); 
    258  
    259         if(mtsrc == NULL) 
    260                 mtsrc = midgard_timestamp_new(); 
    261  
    262         mt->year = mtsrc->year; 
    263         mt->month = mtsrc->month; 
    264         mt->day = mtsrc->day; 
    265  
    266         mt->hour = mtsrc->hour; 
    267         mt->minute = mtsrc->minute; 
    268         mt->second = mtsrc->second; 
    269  
    270         mt->offset = mtsrc->offset; 
    271         mt->nano = mtsrc->nano; 
    272  
    273         mt->date_value = mtsrc->date_value; 
    274  
    275         if (mtsrc->date_string != NULL) 
    276                 mt->date_string = g_strdup(mtsrc->date_string); 
    277  
    278         g_value_take_boxed(dst, mt); 
    279 } 
    280  
    281 static void midgard_timestamp_value_free(GValue *value) 
    282 { 
    283         MidgardTimestamp *mt = (MidgardTimestamp *) g_value_get_boxed(value); 
    284         midgard_timestamp_free(mt);     
     296        mt->year = src->year; 
     297        mt->month = src->month; 
     298        mt->day = src->day; 
     299 
     300        mt->hour = src->hour; 
     301        mt->minute = src->minute; 
     302        mt->second = src->second; 
     303 
     304        mt->offset = src->offset; 
     305        mt->nano = src->nano; 
     306 
     307        mt->date_value = src->date_value; 
     308 
     309        if (src->date_string != NULL) 
     310               mt->date_string = g_strdup (src->date_string); 
     311 
     312        return mt; 
     313} 
     314 
     315void  
     316__midgard_timestamp_free (gpointer boxed) 
     317{ 
     318        MidgardTimestamp *mt = (MidgardTimestamp *) boxed; 
     319        if (mt->date_string) 
     320                g_free (mt->date_string); 
     321        mt->date_string = NULL; 
     322 
     323        g_free (mt); 
    285324 
    286325        return; 
    287 } 
    288  
    289 /* Internal collect function for the midgard_timestamp value type. */ 
    290 static gchar *value_collect_timestamp( 
    291                 GValue *value, guint n_collect_values, 
    292                 GTypeCValue *collect_values, guint collect_flags)  
    293 { 
    294         g_assert(G_VALUE_HOLDS(value, MIDGARD_TYPE_TIMESTAMP)); 
    295         g_assert(n_collect_values == 1); 
    296         g_assert(collect_values != NULL); 
    297  
    298         const gchar *time = (const gchar *) collect_values; 
    299         if (time == NULL) { 
    300                 return g_strdup("Midgard timestamp value string passed as NULL"); 
    301         } 
    302  
    303         return NULL; 
    304 } 
    305  
    306 /* Internal lcopy function for the midgard_timestamp value type. */ 
    307 static gchar *value_lcopy_timestamp( 
    308                 const GValue *value, guint n_collect_values, 
    309                 GTypeCValue *collect_values, guint collect_flags)  
    310 { 
    311         g_assert(G_VALUE_HOLDS(value, MIDGARD_TYPE_TIMESTAMP)); 
    312         g_assert(n_collect_values == 1); 
    313         g_assert(collect_values != NULL); 
    314  
    315         const gchar **time = (const gchar **) collect_values; 
    316         if (time == NULL) { 
    317                 return g_strdup("Midgard timestamp value string passed as NULL"); 
    318         } 
    319  
    320         return NULL; 
    321326} 
    322327 
    …… 
    429434{ 
    430435        static GType type = 0; 
    431  
    432         if (type == 0) { 
    433  
    434                 static const GTypeValueTable value_table = { 
    435                         &value_init_timestamp,     /* value_init */ 
    436                         &midgard_timestamp_value_free,  /* value_free */ 
    437                         &value_copy_timestamp,     /* value_copy */ 
    438                         NULL,                      /* value_peek_pointer */ 
    439                         "p",                       /* collect_format */ 
    440                         &value_collect_timestamp,  /* collect_value */ 
    441                         "p",                       /* lcopy_format */ 
    442                         &value_lcopy_timestamp     /* lcopy_value */ 
    443                 }; 
    444  
    445                 static const GTypeInfo info = { 
    446                         0,                         /* class_size */ 
    447                         NULL,                      /* base_init */ 
    448                         NULL,                      /* base_destroy */ 
    449                         NULL,                      /* class_init */ 
    450                         NULL,                      /* class_destroy */ 
    451                         NULL,                      /* class_data */ 
    452                         0,                         /* instance_size */ 
    453                         0,                         /* n_preallocs */ 
    454                         NULL,                      /* instance_init */ 
    455                         &value_table               /* value_table */ 
    456                 }; 
    457  
    458                 type = g_type_register_static (G_TYPE_BOXED, "MidgardTimestamp", &info, 0); 
    459  
     436  
     437        if (G_UNLIKELY (type == 0)) { 
     438 
     439                type = g_boxed_type_register_static ("MidgardTimestamp", 
     440                                (GBoxedCopyFunc) __midgard_timestamp_copy, 
     441                                (GBoxedFreeFunc) __midgard_timestamp_free); 
     442                 
    460443                /* Register transform functions */ 
    461444                g_value_register_transform_func(type, G_TYPE_STRING, midgard_timestamp_transform_to_string); 
    …… 
    468451} 
    469452 
    470 void midgard_timestamp_set_current_time(const GValue *value) 
    471 { 
    472         g_assert(value != NULL); 
    473         g_return_if_fail(G_VALUE_HOLDS(value, MGD_TYPE_TIMESTAMP)); 
    474  
    475         MidgardTimestamp *mt = (MidgardTimestamp *) g_value_get_boxed(value); 
    476         time_t utctime = time(NULL); 
     453void  
     454midgard_timestamp_set_current_time (const GValue *value) 
     455{ 
     456        g_assert (value != NULL); 
     457        g_return_if_fail (G_VALUE_HOLDS(value, MGD_TYPE_TIMESTAMP)); 
     458 
     459        MidgardTimestamp *mt = (MidgardTimestamp *) g_value_get_boxed (value); 
     460        if (!mt) { 
     461                mt = midgard_timestamp_new (); 
     462                g_value_take_boxed ((GValue *)value, mt); 
     463        } 
     464         
     465        time_t utctime = time (NULL); 
    477466        mt->date_value = utctime + 4611686018427387914ULL;       
    478467        mt->nano = 0; 
    …… 
    489478} 
    490479 
     480void  
     481midgard_core_timestamp_set_current_time (MidgardTimestamp *mt) 
     482{ 
     483        g_return_if_fail (mt != NULL); 
     484 
     485        time_t utctime = time (NULL); 
     486        mt->date_value = utctime + 4611686018427387914ULL;       
     487        mt->nano = 0; 
     488 
     489        __timestamp_struct_reset (mt); 
     490} 
     491 
    491492gchar *midgard_timestamp_get_string(MidgardTimestamp *mt) 
    492493{ 
    …… 
    501502        g_return_val_if_fail(G_VALUE_HOLDS(value, MGD_TYPE_TIMESTAMP), NULL); 
    502503 
    503         MidgardTimestamp *mt = (MidgardTimestamp *) g_value_get_boxed(value); 
     504        MidgardTimestamp *mt = (MidgardTimestamp *) g_value_get_boxed (value); 
    504505 
    505506        return caltime_fmt(mt); 

  • trunk/midgard/core/midgard/src/midgard_timestamp.h

    r24402 r25026  
    5151void                    midgard_timestamp_free                  (MidgardTimestamp *mt); 
    5252 
     53void                    midgard_core_timestamp_set_current_time (MidgardTimestamp *tm); 
     54 
    5355#endif