/src/open5gs/lib/sbi/openapi/model/imsas_info.c

Source

#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include "imsas_info.h"

OpenAPI_imsas_info_t *OpenAPI_imsas_info_create(
    OpenAPI_list_t *ims_event_list
)
{
    OpenAPI_imsas_info_t *imsas_info_local_var = ogs_malloc(sizeof(OpenAPI_imsas_info_t));
    ogs_assert(imsas_info_local_var);

    imsas_info_local_var->ims_event_list = ims_event_list;

    return imsas_info_local_var;
}

void OpenAPI_imsas_info_free(OpenAPI_imsas_info_t *imsas_info)
{
    OpenAPI_lnode_t *node = NULL;

    if (NULL == imsas_info) {
        return;
    }
    if (imsas_info->ims_event_list) {
        OpenAPI_list_free(imsas_info->ims_event_list);
        imsas_info->ims_event_list = NULL;
    }
    ogs_free(imsas_info);
}

cJSON *OpenAPI_imsas_info_convertToJSON(OpenAPI_imsas_info_t *imsas_info)
{
    cJSON *item = NULL;
    OpenAPI_lnode_t *node = NULL;

    if (imsas_info == NULL) {
        ogs_error("OpenAPI_imsas_info_convertToJSON() failed [ImsasInfo]");
        return NULL;
    }

    item = cJSON_CreateObject();
    if (imsas_info->ims_event_list == OpenAPI_ims_event_NULL) {
        ogs_error("OpenAPI_imsas_info_convertToJSON() failed [ims_event_list]");
        return NULL;
    }
    cJSON *ims_event_listList = cJSON_AddArrayToObject(item, "imsEventList");
    if (ims_event_listList == NULL) {
        ogs_error("OpenAPI_imsas_info_convertToJSON() failed [ims_event_list]");
        goto end;
    }
    OpenAPI_list_for_each(imsas_info->ims_event_list, node) {
        if (cJSON_AddStringToObject(ims_event_listList, "", OpenAPI_ims_event_ToString((intptr_t)node->data)) == NULL) {
            ogs_error("OpenAPI_imsas_info_convertToJSON() failed [ims_event_list]");
            goto end;
        }
    }

end:
    return item;
}

OpenAPI_imsas_info_t *OpenAPI_imsas_info_parseFromJSON(cJSON *imsas_infoJSON)
{
    OpenAPI_imsas_info_t *imsas_info_local_var = NULL;
    OpenAPI_lnode_t *node = NULL;
    cJSON *ims_event_list = NULL;
    OpenAPI_list_t *ims_event_listList = NULL;
    ims_event_list = cJSON_GetObjectItemCaseSensitive(imsas_infoJSON, "imsEventList");
    if (!ims_event_list) {
        ogs_error("OpenAPI_imsas_info_parseFromJSON() failed [ims_event_list]");
        goto end;
    }
        cJSON *ims_event_list_local = NULL;
        if (!cJSON_IsArray(ims_event_list)) {
            ogs_error("OpenAPI_imsas_info_parseFromJSON() failed [ims_event_list]");
            goto end;
        }

        ims_event_listList = OpenAPI_list_create();

        cJSON_ArrayForEach(ims_event_list_local, ims_event_list) {
            OpenAPI_ims_event_e localEnum = OpenAPI_ims_event_NULL;
            if (!cJSON_IsString(ims_event_list_local)) {
                ogs_error("OpenAPI_imsas_info_parseFromJSON() failed [ims_event_list]");
                goto end;
            }
            localEnum = OpenAPI_ims_event_FromString(ims_event_list_local->valuestring);
            if (!localEnum) {
                ogs_info("Enum value \"%s\" for field \"ims_event_list\" is not supported. Ignoring it ...",
                         ims_event_list_local->valuestring);
            } else {
                OpenAPI_list_add(ims_event_listList, (void *)localEnum);
            }
        }
        if (ims_event_listList->count == 0) {
            ogs_error("OpenAPI_imsas_info_parseFromJSON() failed: Expected ims_event_listList to not be empty (after ignoring unsupported enum values).");
            goto end;
        }

    imsas_info_local_var = OpenAPI_imsas_info_create (
        ims_event_listList
    );

    return imsas_info_local_var;
end:
    if (ims_event_listList) {
        OpenAPI_list_free(ims_event_listList);
        ims_event_listList = NULL;
    }
    return NULL;
}

OpenAPI_imsas_info_t *OpenAPI_imsas_info_copy(OpenAPI_imsas_info_t *dst, OpenAPI_imsas_info_t *src)
{
    cJSON *item = NULL;
    char *content = NULL;

    ogs_assert(src);
    item = OpenAPI_imsas_info_convertToJSON(src);
    if (!item) {
        ogs_error("OpenAPI_imsas_info_convertToJSON() failed");
        return NULL;
    }

    content = cJSON_Print(item);
    cJSON_Delete(item);

    if (!content) {
        ogs_error("cJSON_Print() failed");
        return NULL;
    }

    item = cJSON_Parse(content);
    ogs_free(content);
    if (!item) {
        ogs_error("cJSON_Parse() failed");
        return NULL;
    }

    OpenAPI_imsas_info_free(dst);
    dst = OpenAPI_imsas_info_parseFromJSON(item);
    cJSON_Delete(item);

    return dst;
}


Line	Count	Source
1
2		#include <stdlib.h>
3		#include <string.h>
4		#include <stdio.h>
5		#include "imsas_info.h"
6
7		OpenAPI_imsas_info_t *OpenAPI_imsas_info_create(
8		OpenAPI_list_t *ims_event_list
9		)
10	17	{
11	17	OpenAPI_imsas_info_t *imsas_info_local_var = ogs_malloc(sizeof(OpenAPI_imsas_info_t));
12	17	ogs_assert(imsas_info_local_var);
13
14	17	imsas_info_local_var->ims_event_list = ims_event_list;
15
16	17	return imsas_info_local_var;
17	17	}
18
19		void OpenAPI_imsas_info_free(OpenAPI_imsas_info_t *imsas_info)
20	17	{
21	17	OpenAPI_lnode_t *node = NULL;
22
23	17	if (NULL == imsas_info) {
24	0	return;
25	0	}
26	17	if (imsas_info->ims_event_list) {
27	17	OpenAPI_list_free(imsas_info->ims_event_list);
28	17	imsas_info->ims_event_list = NULL;
29	17	}
30	17	ogs_free(imsas_info);
31	17	}
32
33		cJSON OpenAPI_imsas_info_convertToJSON(OpenAPI_imsas_info_t imsas_info)
34	0	{
35	0	cJSON *item = NULL;
36	0	OpenAPI_lnode_t *node = NULL;
37
38	0	if (imsas_info == NULL) {
39	0	ogs_error("OpenAPI_imsas_info_convertToJSON() failed [ImsasInfo]");
40	0	return NULL;
41	0	}
42
43	0	item = cJSON_CreateObject();
44	0	if (imsas_info->ims_event_list == OpenAPI_ims_event_NULL) {
45	0	ogs_error("OpenAPI_imsas_info_convertToJSON() failed [ims_event_list]");
46	0	return NULL;
47	0	}
48	0	cJSON *ims_event_listList = cJSON_AddArrayToObject(item, "imsEventList");
49	0	if (ims_event_listList == NULL) {
50	0	ogs_error("OpenAPI_imsas_info_convertToJSON() failed [ims_event_list]");
51	0	goto end;
52	0	}
53	0	OpenAPI_list_for_each(imsas_info->ims_event_list, node) {
54	0	if (cJSON_AddStringToObject(ims_event_listList, "", OpenAPI_ims_event_ToString((intptr_t)node->data)) == NULL) {
55	0	ogs_error("OpenAPI_imsas_info_convertToJSON() failed [ims_event_list]");
56	0	goto end;
57	0	}
58	0	}
59
60	0	end:
61	0	return item;
62	0	}
63
64		OpenAPI_imsas_info_t OpenAPI_imsas_info_parseFromJSON(cJSON imsas_infoJSON)
65	178	{
66	178	OpenAPI_imsas_info_t *imsas_info_local_var = NULL;
67	178	OpenAPI_lnode_t *node = NULL;
68	178	cJSON *ims_event_list = NULL;
69	178	OpenAPI_list_t *ims_event_listList = NULL;
70	178	ims_event_list = cJSON_GetObjectItemCaseSensitive(imsas_infoJSON, "imsEventList");
71	178	if (!ims_event_list) {
72	6	ogs_error("OpenAPI_imsas_info_parseFromJSON() failed [ims_event_list]");
73	6	goto end;
74	6	}
75	172	cJSON *ims_event_list_local = NULL;
76	172	if (!cJSON_IsArray(ims_event_list)) {
77	1	ogs_error("OpenAPI_imsas_info_parseFromJSON() failed [ims_event_list]");
78	1	goto end;
79	1	}
80
81	171	ims_event_listList = OpenAPI_list_create();
82
83	2.28k	cJSON_ArrayForEach(ims_event_list_local, ims_event_list) {
84	2.28k	OpenAPI_ims_event_e localEnum = OpenAPI_ims_event_NULL;
85	2.28k	if (!cJSON_IsString(ims_event_list_local)) {
86	1	ogs_error("OpenAPI_imsas_info_parseFromJSON() failed [ims_event_list]");
87	1	goto end;
88	1	}
89	2.28k	localEnum = OpenAPI_ims_event_FromString(ims_event_list_local->valuestring);
90	2.28k	if (!localEnum) {
91	1.59k	ogs_info("Enum value \"%s\" for field \"ims_event_list\" is not supported. Ignoring it ...",
92	1.59k	ims_event_list_local->valuestring);
93	1.59k	} else {
94	695	OpenAPI_list_add(ims_event_listList, (void *)localEnum);
95	695	}
96	2.28k	}
97	170	if (ims_event_listList->count == 0) {
98	153	ogs_error("OpenAPI_imsas_info_parseFromJSON() failed: Expected ims_event_listList to not be empty (after ignoring unsupported enum values).");
99	153	goto end;
100	153	}
101
102	17	imsas_info_local_var = OpenAPI_imsas_info_create (
103	17	ims_event_listList
104	17	);
105
106	17	return imsas_info_local_var;
107	161	end:
108	161	if (ims_event_listList) {
109	154	OpenAPI_list_free(ims_event_listList);
110	154	ims_event_listList = NULL;
111	154	}
112	161	return NULL;
113	170	}
114
115		OpenAPI_imsas_info_t OpenAPI_imsas_info_copy(OpenAPI_imsas_info_t dst, OpenAPI_imsas_info_t *src)
116	0	{
117	0	cJSON *item = NULL;
118	0	char *content = NULL;
119
120	0	ogs_assert(src);
121	0	item = OpenAPI_imsas_info_convertToJSON(src);
122	0	if (!item) {
123	0	ogs_error("OpenAPI_imsas_info_convertToJSON() failed");
124	0	return NULL;
125	0	}
126
127	0	content = cJSON_Print(item);
128	0	cJSON_Delete(item);
129
130	0	if (!content) {
131	0	ogs_error("cJSON_Print() failed");
132	0	return NULL;
133	0	}
134
135	0	item = cJSON_Parse(content);
136	0	ogs_free(content);
137	0	if (!item) {
138	0	ogs_error("cJSON_Parse() failed");
139	0	return NULL;
140	0	}
141
142	0	OpenAPI_imsas_info_free(dst);
143	0	dst = OpenAPI_imsas_info_parseFromJSON(item);
144	0	cJSON_Delete(item);
145
146	0	return dst;
147	0	}
148

Coverage Report

Created: 2026-09-27 06:19