Bug Summary

File:midgard_core_metadata.c
Location:line 186, column 2
Description:Value stored to 'copy' is never read

Annotated Source Code

1/*
2 * Copyright (C) 2009 Piotr Pokora <piotrek.pokora@gmail.com>
3 *
4 * This program is free software; you can redistribute it and/or modify it
5 * under the terms of the GNU Lesser General Public License as published
6 * by the Free Software Foundation; either version 2 of the License, or
7 * (at your option) any later version.
8 *
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write to the Free Software
16 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17 * */
18
19#include "midgard_core_metadata.h"
20
21#define __SET_METADATA_PROPERTY_STRING(__property, __mstrval){ do { if (__mstrval != ((void*)0)) ; else g_assertion_message_expr
("midgard-core", "src/midgard_core_metadata.c", 21, ((const char
*) (__PRETTY_FUNCTION__)), "__mstrval != NULL"); } while (0);
if (__property != ((void*)0)) g_free(__property); __property
= g_strdup(__mstrval); } { \
22 g_assert(__mstrval != NULL)do { if (__mstrval != ((void*)0)) ; else g_assertion_message_expr
("midgard-core", "src/midgard_core_metadata.c", 22, ((const char
*) (__PRETTY_FUNCTION__)), "__mstrval != NULL"); } while (0); \
23 if (__property != NULL((void*)0)) \
24 g_free(__property); \
25 __property = g_strdup(__mstrval); }
26
27#define __SET_METADATA_PROPERTY_DATE_FROM_STRING(__property, __mstrval){ do { if (__mstrval != ((void*)0)) ; else g_assertion_message_expr
("midgard-core", "src/midgard_core_metadata.c", 27, ((const char
*) (__PRETTY_FUNCTION__)), "__mstrval != NULL"); } while (0);
GTimeVal timeval; g_time_val_from_iso8601(__mstrval, &timeval
); g_date_set_time_val(__property, &timeval); } { \
28 g_assert(__mstrval != NULL)do { if (__mstrval != ((void*)0)) ; else g_assertion_message_expr
("midgard-core", "src/midgard_core_metadata.c", 28, ((const char
*) (__PRETTY_FUNCTION__)), "__mstrval != NULL"); } while (0); \
29 GTimeVal timeval; \
30 g_time_val_from_iso8601(__mstrval, &timeval); \
31 g_date_set_time_val(__property, &timeval); }
32
33#define __SET_METADATA_PROPERTY_DATE_FROM_GVALUE(__property, __value){ do { if (__value != ((void*)0)) ; else g_assertion_message_expr
("midgard-core", "src/midgard_core_metadata.c", 33, ((const char
*) (__PRETTY_FUNCTION__)), "__value != NULL"); } while (0); GValue
__mt = {0, }; g_value_init(&__mt, (midgard_timestamp_get_type
())); if ((((GValue*) (__value))->g_type) == (midgard_timestamp_get_type
())) g_value_copy(__value, &__mt); else g_value_transform
(__value, &__mt); __property = (MidgardTimestamp *) g_value_dup_boxed
(&__mt); g_value_unset(&__mt); } { \
34 g_assert(__value != NULL)do { if (__value != ((void*)0)) ; else g_assertion_message_expr
("midgard-core", "src/midgard_core_metadata.c", 34, ((const char
*) (__PRETTY_FUNCTION__)), "__value != NULL"); } while (0); \
35 /* if (__property != NULL) \
36 g_value_unset(__property); */ \
37 GValue __mt = {0, }; \
38 g_value_init(&__mt, MGD_TYPE_TIMESTAMP(midgard_timestamp_get_type())); \
39 if (G_VALUE_TYPE(__value)(((GValue*) (__value))->g_type) == MGD_TYPE_TIMESTAMP(midgard_timestamp_get_type())) \
40 g_value_copy(__value, &__mt); \
41 else \
42 g_value_transform(__value, &__mt); \
43 __property = (MidgardTimestamp *) g_value_dup_boxed(&__mt); \
44 g_value_unset(&__mt); }
45
46/* setters */
47void midgard_core_metadata_set_creator(MidgardMetadata *self, const gchar *creator)
48{
49 __SET_METADATA_PROPERTY_STRING(self->priv->creator, creator){ do { if (creator != ((void*)0)) ; else g_assertion_message_expr
("midgard-core", "src/midgard_core_metadata.c", 49, ((const char
*) (__PRETTY_FUNCTION__)), "creator != NULL"); } while (0); if
(self->priv->creator != ((void*)0)) g_free(self->priv
->creator); self->priv->creator = g_strdup(creator);
};
50}
51
52void midgard_core_metadata_set_created(MidgardMetadata *self, const GValue *value)
53{
54 __SET_METADATA_PROPERTY_DATE_FROM_GVALUE(self->priv->created, value){ do { if (value != ((void*)0)) ; else g_assertion_message_expr
("midgard-core", "src/midgard_core_metadata.c", 54, ((const char
*) (__PRETTY_FUNCTION__)), "value != NULL"); } while (0); GValue
__mt = {0, }; g_value_init(&__mt, (midgard_timestamp_get_type
())); if ((((GValue*) (value))->g_type) == (midgard_timestamp_get_type
())) g_value_copy(value, &__mt); else g_value_transform(value
, &__mt); self->priv->created = (MidgardTimestamp *
) g_value_dup_boxed(&__mt); g_value_unset(&__mt); };
55}
56
57void midgard_core_metadata_set_revisor(MidgardMetadata *self, const gchar *revisor)
58{
59 __SET_METADATA_PROPERTY_STRING(self->priv->revisor, revisor){ do { if (revisor != ((void*)0)) ; else g_assertion_message_expr
("midgard-core", "src/midgard_core_metadata.c", 59, ((const char
*) (__PRETTY_FUNCTION__)), "revisor != NULL"); } while (0); if
(self->priv->revisor != ((void*)0)) g_free(self->priv
->revisor); self->priv->revisor = g_strdup(revisor);
};
60}
61
62void midgard_core_metadata_set_revised(MidgardMetadata *self, const GValue *revised)
63{
64 __SET_METADATA_PROPERTY_DATE_FROM_GVALUE(self->priv->revised, revised){ do { if (revised != ((void*)0)) ; else g_assertion_message_expr
("midgard-core", "src/midgard_core_metadata.c", 64, ((const char
*) (__PRETTY_FUNCTION__)), "revised != NULL"); } while (0); GValue
__mt = {0, }; g_value_init(&__mt, (midgard_timestamp_get_type
())); if ((((GValue*) (revised))->g_type) == (midgard_timestamp_get_type
())) g_value_copy(revised, &__mt); else g_value_transform
(revised, &__mt); self->priv->revised = (MidgardTimestamp
*) g_value_dup_boxed(&__mt); g_value_unset(&__mt); };
65}
66
67void midgard_core_metadata_set_revision(MidgardMetadata *self, guint revision)
68{
69 self->priv->revision = revision;
70}
71
72void midgard_core_metadata_set_locker(MidgardMetadata *self, const gchar *locker)
73{
74 __SET_METADATA_PROPERTY_STRING(self->priv->locker, locker){ do { if (locker != ((void*)0)) ; else g_assertion_message_expr
("midgard-core", "src/midgard_core_metadata.c", 74, ((const char
*) (__PRETTY_FUNCTION__)), "locker != NULL"); } while (0); if
(self->priv->locker != ((void*)0)) g_free(self->priv
->locker); self->priv->locker = g_strdup(locker); };
75}
76
77void midgard_core_metadata_set_locked(MidgardMetadata *self, const GValue *locked)
78{
79 __SET_METADATA_PROPERTY_DATE_FROM_GVALUE(self->priv->locked, locked){ do { if (locked != ((void*)0)) ; else g_assertion_message_expr
("midgard-core", "src/midgard_core_metadata.c", 79, ((const char
*) (__PRETTY_FUNCTION__)), "locked != NULL"); } while (0); GValue
__mt = {0, }; g_value_init(&__mt, (midgard_timestamp_get_type
())); if ((((GValue*) (locked))->g_type) == (midgard_timestamp_get_type
())) g_value_copy(locked, &__mt); else g_value_transform(
locked, &__mt); self->priv->locked = (MidgardTimestamp
*) g_value_dup_boxed(&__mt); g_value_unset(&__mt); };
80}
81
82void midgard_core_metadata_set_approver(MidgardMetadata *self, const gchar *approver)
83{
84 __SET_METADATA_PROPERTY_STRING(self->priv->approver, approver){ do { if (approver != ((void*)0)) ; else g_assertion_message_expr
("midgard-core", "src/midgard_core_metadata.c", 84, ((const char
*) (__PRETTY_FUNCTION__)), "approver != NULL"); } while (0); if
(self->priv->approver != ((void*)0)) g_free(self->priv
->approver); self->priv->approver = g_strdup(approver
); };
85}
86
87void midgard_core_metadata_set_approved(MidgardMetadata *self, const GValue *approved)
88{
89 __SET_METADATA_PROPERTY_DATE_FROM_GVALUE(self->priv->approved, approved){ do { if (approved != ((void*)0)) ; else g_assertion_message_expr
("midgard-core", "src/midgard_core_metadata.c", 89, ((const char
*) (__PRETTY_FUNCTION__)), "approved != NULL"); } while (0); GValue
__mt = {0, }; g_value_init(&__mt, (midgard_timestamp_get_type
())); if ((((GValue*) (approved))->g_type) == (midgard_timestamp_get_type
())) g_value_copy(approved, &__mt); else g_value_transform
(approved, &__mt); self->priv->approved = (MidgardTimestamp
*) g_value_dup_boxed(&__mt); g_value_unset(&__mt); };
90}
91
92void midgard_core_metadata_set_size(MidgardMetadata *self, guint size)
93{
94 self->priv->size = size;
95}
96
97void midgard_core_metadata_set_exported(MidgardMetadata *self, const GValue *exported)
98{
99 __SET_METADATA_PROPERTY_DATE_FROM_GVALUE(self->priv->exported, exported){ do { if (exported != ((void*)0)) ; else g_assertion_message_expr
("midgard-core", "src/midgard_core_metadata.c", 99, ((const char
*) (__PRETTY_FUNCTION__)), "exported != NULL"); } while (0); GValue
__mt = {0, }; g_value_init(&__mt, (midgard_timestamp_get_type
())); if ((((GValue*) (exported))->g_type) == (midgard_timestamp_get_type
())) g_value_copy(exported, &__mt); else g_value_transform
(exported, &__mt); self->priv->exported = (MidgardTimestamp
*) g_value_dup_boxed(&__mt); g_value_unset(&__mt); };
100}
101
102void midgard_core_metadata_set_imported(MidgardMetadata *self, const GValue *imported)
103{
104 __SET_METADATA_PROPERTY_DATE_FROM_GVALUE(self->priv->imported, imported){ do { if (imported != ((void*)0)) ; else g_assertion_message_expr
("midgard-core", "src/midgard_core_metadata.c", 104, ((const
char*) (__PRETTY_FUNCTION__)), "imported != NULL"); } while (
0); GValue __mt = {0, }; g_value_init(&__mt, (midgard_timestamp_get_type
())); if ((((GValue*) (imported))->g_type) == (midgard_timestamp_get_type
())) g_value_copy(imported, &__mt); else g_value_transform
(imported, &__mt); self->priv->imported = (MidgardTimestamp
*) g_value_dup_boxed(&__mt); g_value_unset(&__mt); };
105}
106
107void midgard_core_metadata_set_deleted(MidgardMetadata *self, gboolean deleted)
108{
109 self->priv->deleted = deleted;
110}
111
112void midgard_core_metadata_set_isapproved(MidgardMetadata *self, gboolean isapproved)
113{
114 self->priv->is_approved = isapproved;
115}
116
117void midgard_core_metadata_set_islocked(MidgardMetadata *self, gboolean islocked)
118{
119 self->priv->is_locked = islocked;
120}
121
122/* routines */
123void midgard_core_metadata_increase_revision(MidgardMetadata *self)
124{
125 self->priv->revision++;
126}
127
128#define get_varchar_size(__prop)if (__prop == ((void*)0)) size++; else size += strlen((const gchar
*)__prop) + 1; \
129 if (__prop == NULL((void*)0)) \
130 size++; \
131 else \
132 size += strlen((const gchar *)__prop) + 1;
133
134guint midgard_core_metadata_get_size(MidgardMetadata *self)
135{
136 guint size = 0;
137
138 /* CHAR */
139
140 /* creator */
141 get_varchar_size(self->priv->creator)if (self->priv->creator == ((void*)0)) size++; else size
+= strlen((const gchar *)self->priv->creator) + 1;;
142
143 /* revisor */
144 get_varchar_size(self->priv->revisor)if (self->priv->revisor == ((void*)0)) size++; else size
+= strlen((const gchar *)self->priv->revisor) + 1;;
145
146 /* locker */
147 get_varchar_size(self->priv->locker)if (self->priv->locker == ((void*)0)) size++; else size
+= strlen((const gchar *)self->priv->locker) + 1;;
148
149 /* authors */
150 get_varchar_size(self->priv->authors)if (self->priv->authors == ((void*)0)) size++; else size
+= strlen((const gchar *)self->priv->authors) + 1;;
151
152 /* owner */
153 get_varchar_size(self->priv->owner)if (self->priv->owner == ((void*)0)) size++; else size +=
strlen((const gchar *)self->priv->owner) + 1;;
154
155 /* DATETIME */
156 /* datetime needs 8 bytes (MySQL at least).
157 * I do not use strlen here to avoid GValue conversion */
158 /* created, revised, locked, approved, published, schedulestart,
159 * scheduleend, locked, approved, exported, imported */
160 size += (11 * 8);
161
162 /* BOOLEAN */
163 /* hidden, nav-noentry , revision, is_locked, is_approved, deleted */
164 size += (6 * 4);
165
166 /* INT */
167 /* size, score */
168 size += (2 * 4);
169
170 return size;
171}
172
173/* This is temporary routine. Ragnaroek compatible.
174 * If it's needed for longer period, core's timestamp API should be provided */
175void __copy_date(const MidgardTimestamp *src, MidgardTimestamp *copy)
176{
177 GValue srcv = {0, };
178 GValue dstv = {0, };
179
180 g_value_init(&srcv, MGD_TYPE_TIMESTAMP(midgard_timestamp_get_type()));
181 g_value_init(&dstv, MGD_TYPE_TIMESTAMP(midgard_timestamp_get_type()));
182
183 g_value_set_boxed(&srcv, src);
184 g_value_copy(&srcv, &dstv);
185
186 copy = (MidgardTimestamp *) g_value_dup_boxed(&dstv);
Value stored to 'copy' is never read
187
188 g_value_unset(&srcv);
189 g_value_unset(&dstv);
190
191 return;
192}
193
194MidgardMetadata *midgard_core_metadata_copy(MidgardMetadata *src)
195{
196 g_assert(src != NULL)do { if (src != ((void*)0)) ; else g_assertion_message_expr (
"midgard-core", "src/midgard_core_metadata.c", 196, ((const char
*) (__PRETTY_FUNCTION__)), "src != NULL"); } while (0);
197
198 /* Initialize it that way so all callbacks are correctly set */
199 MidgardMetadata *copy = midgard_metadata_new(src->priv->object);
200
201 g_assert(copy != NULL)do { if (copy != ((void*)0)) ; else g_assertion_message_expr (
"midgard-core", "src/midgard_core_metadata.c", 201, ((const char
*) (__PRETTY_FUNCTION__)), "copy != NULL"); } while (0);
202
203 if (src->priv->creator != NULL((void*)0))
204 midgard_core_metadata_set_creator(copy, src->priv->creator);
205
206 /* created */
207 __copy_date(src->priv->created, copy->priv->created);
208
209 /* revised */
210 __copy_date(src->priv->revised, copy->priv->revised);
211
212 if (src->priv->revisor != NULL((void*)0))
213 midgard_core_metadata_set_revisor(copy, src->priv->revisor);
214
215 if (src->priv->locker != NULL((void*)0))
216 midgard_core_metadata_set_locker(copy, src->priv->locker);
217
218 /* locked */
219 __copy_date(src->priv->locked, copy->priv->locked);
220
221 /* approved */
222 __copy_date(src->priv->approved, copy->priv->approved);
223
224 if (src->priv->approver != NULL((void*)0))
225 midgard_core_metadata_set_approver(copy, src->priv->approver);
226
227 if (src->priv->authors != NULL((void*)0)) {
228
229 g_free(copy->priv->authors);
230 copy->priv->authors = g_strdup(src->priv->authors);
231 }
232
233 if (src->priv->owner != NULL((void*)0) ) {
234
235 g_free(copy->priv->owner);
236 copy->priv->owner = g_strdup(src->priv->owner);
237 }
238
239 copy->priv->revision = src->priv->revision;
240
241 /* schedule_start */
242 __copy_date(src->priv->schedule_start, copy->priv->schedule_start);
243
244 /* schedule_end */
245 __copy_date(src->priv->schedule_end, copy->priv->schedule_end);
246
247 copy->priv->hidden = src->priv->hidden;
248
249 copy->priv->nav_noentry = src->priv->nav_noentry;
250 copy->priv->size = src->priv->size;
251
252 /* published */
253 __copy_date(src->priv->published, copy->priv->published);
254
255 copy->priv->score = src->priv->score;
256
257 /* exported */
258 __copy_date(src->priv->exported, copy->priv->exported);
259
260 /* imported */
261 __copy_date(src->priv->imported, copy->priv->imported);
262
263 copy->priv->deleted = src->priv->deleted;
264
265 copy->priv->lock_is_set = src->priv->lock_is_set;
266
267 copy->priv->is_locked = src->priv->is_locked;
268
269 copy->priv->approve_is_set = src->priv->approve_is_set;
270
271 copy->priv->is_approved = src->priv->is_approved;
272
273 return copy;
274}