Line data Source code
1 : /* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
2 : /*
3 : * lt-grandfathered.c
4 : * Copyright (C) 2011-2012 Akira TAGOH
5 : *
6 : * Authors:
7 : * Akira TAGOH <akira@tagoh.org>
8 : *
9 : * You may distribute under the terms of either the GNU
10 : * Lesser General Public License or the Mozilla Public
11 : * License, as specified in the README file.
12 : */
13 : #ifdef HAVE_CONFIG_H
14 : #include "config.h"
15 : #endif
16 :
17 : #include <stdlib.h>
18 : #include <string.h>
19 : #include "lt-mem.h"
20 : #include "lt-messages.h"
21 : #include "lt-string.h"
22 : #include "lt-utils.h"
23 : #include "lt-grandfathered.h"
24 : #include "lt-grandfathered-private.h"
25 :
26 :
27 : /**
28 : * SECTION: lt-grandfathered
29 : * @Short_Description: A container class for Grandfathered subtag
30 : * @Title: Container - Grandfathered
31 : *
32 : * This container class provides a data access to Grandfathered subtag entry.
33 : */
34 : struct _lt_grandfathered_t {
35 : lt_mem_t parent;
36 : char *tag;
37 : char *description;
38 : char *preferred_tag;
39 : };
40 :
41 : /*< private >*/
42 :
43 : /*< protected >*/
44 : lt_grandfathered_t *
45 104 : lt_grandfathered_create(void)
46 : {
47 : lt_grandfathered_t *retval;
48 :
49 104 : retval = lt_mem_alloc_object(sizeof (lt_grandfathered_t));
50 :
51 104 : return retval;
52 : }
53 :
54 : void
55 104 : lt_grandfathered_set_tag(lt_grandfathered_t *grandfathered,
56 : const char *tag)
57 : {
58 104 : lt_return_if_fail (grandfathered != NULL);
59 104 : lt_return_if_fail (tag != NULL);
60 :
61 104 : if (grandfathered->tag)
62 0 : lt_mem_delete_ref(&grandfathered->parent, grandfathered->tag);
63 104 : grandfathered->tag = strdup(tag);
64 104 : lt_mem_add_ref(&grandfathered->parent, grandfathered->tag, free);
65 : }
66 :
67 : void
68 104 : lt_grandfathered_set_name(lt_grandfathered_t *grandfathered,
69 : const char *description)
70 : {
71 104 : lt_return_if_fail (grandfathered != NULL);
72 104 : lt_return_if_fail (description != NULL);
73 :
74 104 : if (grandfathered->description)
75 0 : lt_mem_delete_ref(&grandfathered->parent, grandfathered->description);
76 104 : grandfathered->description = strdup(description);
77 104 : lt_mem_add_ref(&grandfathered->parent, grandfathered->description, free);
78 : }
79 :
80 : void
81 80 : lt_grandfathered_set_preferred_tag(lt_grandfathered_t *grandfathered,
82 : const char *subtag)
83 : {
84 80 : lt_return_if_fail (grandfathered != NULL);
85 80 : lt_return_if_fail (subtag != NULL);
86 :
87 80 : if (grandfathered->preferred_tag)
88 0 : lt_mem_delete_ref(&grandfathered->parent, grandfathered->preferred_tag);
89 80 : grandfathered->preferred_tag = strdup(subtag);
90 80 : lt_mem_add_ref(&grandfathered->parent, grandfathered->preferred_tag, free);
91 : }
92 :
93 : /*< public >*/
94 : /**
95 : * lt_grandfathered_ref:
96 : * @grandfathered: a #lt_grandfathered_t.
97 : *
98 : * Increases the reference count of @grandfathered.
99 : *
100 : * Returns: (transfer none): the same @grandfathered object.
101 : */
102 : lt_grandfathered_t *
103 106 : lt_grandfathered_ref(lt_grandfathered_t *grandfathered)
104 : {
105 106 : lt_return_val_if_fail (grandfathered != NULL, NULL);
106 :
107 106 : return lt_mem_ref(&grandfathered->parent);
108 : }
109 :
110 : /**
111 : * lt_grandfathered_unref:
112 : * @grandfathered: a #lt_grandfathered_t.
113 : *
114 : * Decreases the reference count of @grandfathered. when its reference count
115 : * drops to 0, the object is finalized (i.e. its memory is freed).
116 : */
117 : void
118 210 : lt_grandfathered_unref(lt_grandfathered_t *grandfathered)
119 : {
120 210 : if (grandfathered)
121 210 : lt_mem_unref(&grandfathered->parent);
122 210 : }
123 :
124 : /**
125 : * lt_grandfathered_get_better_tag:
126 : * @grandfathered: a #lt_grandfathered_t.
127 : *
128 : * Obtains the better tag for use. this is a convenient function to get
129 : * the preferred-value if available.
130 : *
131 : * Returns: a tag string.
132 : */
133 : const char *
134 2 : lt_grandfathered_get_better_tag(const lt_grandfathered_t *grandfathered)
135 : {
136 2 : const char *retval = lt_grandfathered_get_preferred_tag(grandfathered);
137 :
138 2 : if (!retval)
139 0 : retval = lt_grandfathered_get_tag(grandfathered);
140 :
141 2 : return retval;
142 : }
143 :
144 : /**
145 : * lt_grandfathered_get_tag:
146 : * @grandfathered: a #lt_grandfathered_t.
147 : *
148 : * Obtains the tag name.
149 : *
150 : * Returns: a tag string.
151 : */
152 : const char *
153 104 : lt_grandfathered_get_tag(const lt_grandfathered_t *grandfathered)
154 : {
155 104 : lt_return_val_if_fail (grandfathered != NULL, NULL);
156 :
157 104 : return grandfathered->tag;
158 : }
159 :
160 : /**
161 : * lt_grandfathered_get_name:
162 : * @grandfathered: a #lt_grandfathered_t.
163 : *
164 : * Obtains the description of the tag.
165 : *
166 : * Returns: a description string.
167 : */
168 : const char *
169 0 : lt_grandfathered_get_name(const lt_grandfathered_t *grandfathered)
170 : {
171 0 : lt_return_val_if_fail (grandfathered != NULL, NULL);
172 :
173 0 : return grandfathered->description;
174 : }
175 :
176 : /**
177 : * lt_grandfathered_get_preferred_tag:
178 : * @grandfathered: a #lt_grandfathered_t.
179 : *
180 : * Obtains the preferred-value. this is available only when the tag is
181 : * marked as deprecated.
182 : *
183 : * Returns: a preferred-value for the tag or %NULL.
184 : */
185 : const char *
186 2 : lt_grandfathered_get_preferred_tag(const lt_grandfathered_t *grandfathered)
187 : {
188 2 : lt_return_val_if_fail (grandfathered != NULL, NULL);
189 :
190 2 : return grandfathered->preferred_tag;
191 : }
192 :
193 : /**
194 : * lt_grandfathered_dump:
195 : * @grandfathered: a #lt_grandfathered_t.
196 : *
197 : * Dumps the container information to the standard output.
198 : */
199 : void
200 0 : lt_grandfathered_dump(const lt_grandfathered_t *grandfathered)
201 : {
202 0 : const char *preferred = lt_grandfathered_get_preferred_tag(grandfathered);
203 0 : lt_string_t *string = lt_string_new(NULL);
204 :
205 0 : if (preferred) {
206 0 : if (lt_string_length(string) == 0)
207 0 : lt_string_append(string, " (");
208 0 : lt_string_append_printf(string, "preferred-value: %s",
209 : preferred);
210 : }
211 0 : if (lt_string_length(string) > 0)
212 0 : lt_string_append(string, ")");
213 :
214 0 : lt_info("Grandfathered: %s [%s]%s",
215 : lt_grandfathered_get_tag(grandfathered),
216 : lt_grandfathered_get_name(grandfathered),
217 : lt_string_value(string));
218 :
219 0 : lt_string_unref(string);
220 0 : }
221 :
222 : /**
223 : * lt_grandfathered_compare:
224 : * @v1: a #lt_grandfathered_t.
225 : * @v2: a #lt_grandfathered_t.
226 : *
227 : * Compare if @v1 and @v2 is the same object or not.
228 : *
229 : * Returns: %TRUE if it's the same. otherwise %FALSE.
230 : */
231 : lt_bool_t
232 0 : lt_grandfathered_compare(const lt_grandfathered_t *v1,
233 : const lt_grandfathered_t *v2)
234 : {
235 0 : lt_return_val_if_fail (v1 != NULL, FALSE);
236 0 : lt_return_val_if_fail (v2 != NULL, FALSE);
237 :
238 0 : if (v1 == v2)
239 0 : return TRUE;
240 :
241 0 : return lt_strcmp0(lt_grandfathered_get_tag(v1), lt_grandfathered_get_tag(v2)) == 0;
242 : }
|
