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

Source

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

OpenAPI_dcsf_info_t *OpenAPI_dcsf_info_create(
    OpenAPI_list_t *ims_domain_name_list,
    OpenAPI_list_t *imsi_ranges,
    OpenAPI_list_t *ims_private_identity_ranges,
    OpenAPI_list_t *ims_public_identity_ranges,
    OpenAPI_list_t *msisdn_ranges
)
{
    OpenAPI_dcsf_info_t *dcsf_info_local_var = ogs_malloc(sizeof(OpenAPI_dcsf_info_t));
    ogs_assert(dcsf_info_local_var);

    dcsf_info_local_var->ims_domain_name_list = ims_domain_name_list;
    dcsf_info_local_var->imsi_ranges = imsi_ranges;
    dcsf_info_local_var->ims_private_identity_ranges = ims_private_identity_ranges;
    dcsf_info_local_var->ims_public_identity_ranges = ims_public_identity_ranges;
    dcsf_info_local_var->msisdn_ranges = msisdn_ranges;

    return dcsf_info_local_var;
}

void OpenAPI_dcsf_info_free(OpenAPI_dcsf_info_t *dcsf_info)
{
    OpenAPI_lnode_t *node = NULL;

    if (NULL == dcsf_info) {
        return;
    }
    if (dcsf_info->ims_domain_name_list) {
        OpenAPI_list_for_each(dcsf_info->ims_domain_name_list, node) {
            ogs_free(node->data);
        }
        OpenAPI_list_free(dcsf_info->ims_domain_name_list);
        dcsf_info->ims_domain_name_list = NULL;
    }
    if (dcsf_info->imsi_ranges) {
        OpenAPI_list_for_each(dcsf_info->imsi_ranges, node) {
            OpenAPI_imsi_range_free(node->data);
        }
        OpenAPI_list_free(dcsf_info->imsi_ranges);
        dcsf_info->imsi_ranges = NULL;
    }
    if (dcsf_info->ims_private_identity_ranges) {
        OpenAPI_list_for_each(dcsf_info->ims_private_identity_ranges, node) {
            OpenAPI_identity_range_free(node->data);
        }
        OpenAPI_list_free(dcsf_info->ims_private_identity_ranges);
        dcsf_info->ims_private_identity_ranges = NULL;
    }
    if (dcsf_info->ims_public_identity_ranges) {
        OpenAPI_list_for_each(dcsf_info->ims_public_identity_ranges, node) {
            OpenAPI_identity_range_free(node->data);
        }
        OpenAPI_list_free(dcsf_info->ims_public_identity_ranges);
        dcsf_info->ims_public_identity_ranges = NULL;
    }
    if (dcsf_info->msisdn_ranges) {
        OpenAPI_list_for_each(dcsf_info->msisdn_ranges, node) {
            OpenAPI_identity_range_free(node->data);
        }
        OpenAPI_list_free(dcsf_info->msisdn_ranges);
        dcsf_info->msisdn_ranges = NULL;
    }
    ogs_free(dcsf_info);
}

cJSON *OpenAPI_dcsf_info_convertToJSON(OpenAPI_dcsf_info_t *dcsf_info)
{
    cJSON *item = NULL;
    OpenAPI_lnode_t *node = NULL;

    if (dcsf_info == NULL) {
        ogs_error("OpenAPI_dcsf_info_convertToJSON() failed [DcsfInfo]");
        return NULL;
    }

    item = cJSON_CreateObject();
    if (dcsf_info->ims_domain_name_list) {
    cJSON *ims_domain_name_listList = cJSON_AddArrayToObject(item, "imsDomainNameList");
    if (ims_domain_name_listList == NULL) {
        ogs_error("OpenAPI_dcsf_info_convertToJSON() failed [ims_domain_name_list]");
        goto end;
    }
    OpenAPI_list_for_each(dcsf_info->ims_domain_name_list, node) {
        if (cJSON_AddStringToObject(ims_domain_name_listList, "", (char*)node->data) == NULL) {
            ogs_error("OpenAPI_dcsf_info_convertToJSON() failed [ims_domain_name_list]");
            goto end;
        }
    }
    }

    if (dcsf_info->imsi_ranges) {
    cJSON *imsi_rangesList = cJSON_AddArrayToObject(item, "imsiRanges");
    if (imsi_rangesList == NULL) {
        ogs_error("OpenAPI_dcsf_info_convertToJSON() failed [imsi_ranges]");
        goto end;
    }
    OpenAPI_list_for_each(dcsf_info->imsi_ranges, node) {
        cJSON *itemLocal = OpenAPI_imsi_range_convertToJSON(node->data);
        if (itemLocal == NULL) {
            ogs_error("OpenAPI_dcsf_info_convertToJSON() failed [imsi_ranges]");
            goto end;
        }
        cJSON_AddItemToArray(imsi_rangesList, itemLocal);
    }
    }

    if (dcsf_info->ims_private_identity_ranges) {
    cJSON *ims_private_identity_rangesList = cJSON_AddArrayToObject(item, "imsPrivateIdentityRanges");
    if (ims_private_identity_rangesList == NULL) {
        ogs_error("OpenAPI_dcsf_info_convertToJSON() failed [ims_private_identity_ranges]");
        goto end;
    }
    OpenAPI_list_for_each(dcsf_info->ims_private_identity_ranges, node) {
        cJSON *itemLocal = OpenAPI_identity_range_convertToJSON(node->data);
        if (itemLocal == NULL) {
            ogs_error("OpenAPI_dcsf_info_convertToJSON() failed [ims_private_identity_ranges]");
            goto end;
        }
        cJSON_AddItemToArray(ims_private_identity_rangesList, itemLocal);
    }
    }

    if (dcsf_info->ims_public_identity_ranges) {
    cJSON *ims_public_identity_rangesList = cJSON_AddArrayToObject(item, "imsPublicIdentityRanges");
    if (ims_public_identity_rangesList == NULL) {
        ogs_error("OpenAPI_dcsf_info_convertToJSON() failed [ims_public_identity_ranges]");
        goto end;
    }
    OpenAPI_list_for_each(dcsf_info->ims_public_identity_ranges, node) {
        cJSON *itemLocal = OpenAPI_identity_range_convertToJSON(node->data);
        if (itemLocal == NULL) {
            ogs_error("OpenAPI_dcsf_info_convertToJSON() failed [ims_public_identity_ranges]");
            goto end;
        }
        cJSON_AddItemToArray(ims_public_identity_rangesList, itemLocal);
    }
    }

    if (dcsf_info->msisdn_ranges) {
    cJSON *msisdn_rangesList = cJSON_AddArrayToObject(item, "msisdnRanges");
    if (msisdn_rangesList == NULL) {
        ogs_error("OpenAPI_dcsf_info_convertToJSON() failed [msisdn_ranges]");
        goto end;
    }
    OpenAPI_list_for_each(dcsf_info->msisdn_ranges, node) {
        cJSON *itemLocal = OpenAPI_identity_range_convertToJSON(node->data);
        if (itemLocal == NULL) {
            ogs_error("OpenAPI_dcsf_info_convertToJSON() failed [msisdn_ranges]");
            goto end;
        }
        cJSON_AddItemToArray(msisdn_rangesList, itemLocal);
    }
    }

end:
    return item;
}

OpenAPI_dcsf_info_t *OpenAPI_dcsf_info_parseFromJSON(cJSON *dcsf_infoJSON)
{
    OpenAPI_dcsf_info_t *dcsf_info_local_var = NULL;
    OpenAPI_lnode_t *node = NULL;
    cJSON *ims_domain_name_list = NULL;
    OpenAPI_list_t *ims_domain_name_listList = NULL;
    cJSON *imsi_ranges = NULL;
    OpenAPI_list_t *imsi_rangesList = NULL;
    cJSON *ims_private_identity_ranges = NULL;
    OpenAPI_list_t *ims_private_identity_rangesList = NULL;
    cJSON *ims_public_identity_ranges = NULL;
    OpenAPI_list_t *ims_public_identity_rangesList = NULL;
    cJSON *msisdn_ranges = NULL;
    OpenAPI_list_t *msisdn_rangesList = NULL;
    ims_domain_name_list = cJSON_GetObjectItemCaseSensitive(dcsf_infoJSON, "imsDomainNameList");
    if (ims_domain_name_list) {
        cJSON *ims_domain_name_list_local = NULL;
        if (!cJSON_IsArray(ims_domain_name_list)) {
            ogs_error("OpenAPI_dcsf_info_parseFromJSON() failed [ims_domain_name_list]");
            goto end;
        }

        ims_domain_name_listList = OpenAPI_list_create();

        cJSON_ArrayForEach(ims_domain_name_list_local, ims_domain_name_list) {
            double *localDouble = NULL;
            int *localInt = NULL;
            if (!cJSON_IsString(ims_domain_name_list_local)) {
                ogs_error("OpenAPI_dcsf_info_parseFromJSON() failed [ims_domain_name_list]");
                goto end;
            }
            OpenAPI_list_add(ims_domain_name_listList, ogs_strdup(ims_domain_name_list_local->valuestring));
        }
    }

    imsi_ranges = cJSON_GetObjectItemCaseSensitive(dcsf_infoJSON, "imsiRanges");
    if (imsi_ranges) {
        cJSON *imsi_ranges_local = NULL;
        if (!cJSON_IsArray(imsi_ranges)) {
            ogs_error("OpenAPI_dcsf_info_parseFromJSON() failed [imsi_ranges]");
            goto end;
        }

        imsi_rangesList = OpenAPI_list_create();

        cJSON_ArrayForEach(imsi_ranges_local, imsi_ranges) {
            if (!cJSON_IsObject(imsi_ranges_local)) {
                ogs_error("OpenAPI_dcsf_info_parseFromJSON() failed [imsi_ranges]");
                goto end;
            }
            OpenAPI_imsi_range_t *imsi_rangesItem = OpenAPI_imsi_range_parseFromJSON(imsi_ranges_local);
            if (!imsi_rangesItem) {
                ogs_error("No imsi_rangesItem");
                goto end;
            }
            OpenAPI_list_add(imsi_rangesList, imsi_rangesItem);
        }
    }

    ims_private_identity_ranges = cJSON_GetObjectItemCaseSensitive(dcsf_infoJSON, "imsPrivateIdentityRanges");
    if (ims_private_identity_ranges) {
        cJSON *ims_private_identity_ranges_local = NULL;
        if (!cJSON_IsArray(ims_private_identity_ranges)) {
            ogs_error("OpenAPI_dcsf_info_parseFromJSON() failed [ims_private_identity_ranges]");
            goto end;
        }

        ims_private_identity_rangesList = OpenAPI_list_create();

        cJSON_ArrayForEach(ims_private_identity_ranges_local, ims_private_identity_ranges) {
            if (!cJSON_IsObject(ims_private_identity_ranges_local)) {
                ogs_error("OpenAPI_dcsf_info_parseFromJSON() failed [ims_private_identity_ranges]");
                goto end;
            }
            OpenAPI_identity_range_t *ims_private_identity_rangesItem = OpenAPI_identity_range_parseFromJSON(ims_private_identity_ranges_local);
            if (!ims_private_identity_rangesItem) {
                ogs_error("No ims_private_identity_rangesItem");
                goto end;
            }
            OpenAPI_list_add(ims_private_identity_rangesList, ims_private_identity_rangesItem);
        }
    }

    ims_public_identity_ranges = cJSON_GetObjectItemCaseSensitive(dcsf_infoJSON, "imsPublicIdentityRanges");
    if (ims_public_identity_ranges) {
        cJSON *ims_public_identity_ranges_local = NULL;
        if (!cJSON_IsArray(ims_public_identity_ranges)) {
            ogs_error("OpenAPI_dcsf_info_parseFromJSON() failed [ims_public_identity_ranges]");
            goto end;
        }

        ims_public_identity_rangesList = OpenAPI_list_create();

        cJSON_ArrayForEach(ims_public_identity_ranges_local, ims_public_identity_ranges) {
            if (!cJSON_IsObject(ims_public_identity_ranges_local)) {
                ogs_error("OpenAPI_dcsf_info_parseFromJSON() failed [ims_public_identity_ranges]");
                goto end;
            }
            OpenAPI_identity_range_t *ims_public_identity_rangesItem = OpenAPI_identity_range_parseFromJSON(ims_public_identity_ranges_local);
            if (!ims_public_identity_rangesItem) {
                ogs_error("No ims_public_identity_rangesItem");
                goto end;
            }
            OpenAPI_list_add(ims_public_identity_rangesList, ims_public_identity_rangesItem);
        }
    }

    msisdn_ranges = cJSON_GetObjectItemCaseSensitive(dcsf_infoJSON, "msisdnRanges");
    if (msisdn_ranges) {
        cJSON *msisdn_ranges_local = NULL;
        if (!cJSON_IsArray(msisdn_ranges)) {
            ogs_error("OpenAPI_dcsf_info_parseFromJSON() failed [msisdn_ranges]");
            goto end;
        }

        msisdn_rangesList = OpenAPI_list_create();

        cJSON_ArrayForEach(msisdn_ranges_local, msisdn_ranges) {
            if (!cJSON_IsObject(msisdn_ranges_local)) {
                ogs_error("OpenAPI_dcsf_info_parseFromJSON() failed [msisdn_ranges]");
                goto end;
            }
            OpenAPI_identity_range_t *msisdn_rangesItem = OpenAPI_identity_range_parseFromJSON(msisdn_ranges_local);
            if (!msisdn_rangesItem) {
                ogs_error("No msisdn_rangesItem");
                goto end;
            }
            OpenAPI_list_add(msisdn_rangesList, msisdn_rangesItem);
        }
    }

    dcsf_info_local_var = OpenAPI_dcsf_info_create (
        ims_domain_name_list ? ims_domain_name_listList : NULL,
        imsi_ranges ? imsi_rangesList : NULL,
        ims_private_identity_ranges ? ims_private_identity_rangesList : NULL,
        ims_public_identity_ranges ? ims_public_identity_rangesList : NULL,
        msisdn_ranges ? msisdn_rangesList : NULL
    );

    return dcsf_info_local_var;
end:
    if (ims_domain_name_listList) {
        OpenAPI_list_for_each(ims_domain_name_listList, node) {
            ogs_free(node->data);
        }
        OpenAPI_list_free(ims_domain_name_listList);
        ims_domain_name_listList = NULL;
    }
    if (imsi_rangesList) {
        OpenAPI_list_for_each(imsi_rangesList, node) {
            OpenAPI_imsi_range_free(node->data);
        }
        OpenAPI_list_free(imsi_rangesList);
        imsi_rangesList = NULL;
    }
    if (ims_private_identity_rangesList) {
        OpenAPI_list_for_each(ims_private_identity_rangesList, node) {
            OpenAPI_identity_range_free(node->data);
        }
        OpenAPI_list_free(ims_private_identity_rangesList);
        ims_private_identity_rangesList = NULL;
    }
    if (ims_public_identity_rangesList) {
        OpenAPI_list_for_each(ims_public_identity_rangesList, node) {
            OpenAPI_identity_range_free(node->data);
        }
        OpenAPI_list_free(ims_public_identity_rangesList);
        ims_public_identity_rangesList = NULL;
    }
    if (msisdn_rangesList) {
        OpenAPI_list_for_each(msisdn_rangesList, node) {
            OpenAPI_identity_range_free(node->data);
        }
        OpenAPI_list_free(msisdn_rangesList);
        msisdn_rangesList = NULL;
    }
    return NULL;
}

OpenAPI_dcsf_info_t *OpenAPI_dcsf_info_copy(OpenAPI_dcsf_info_t *dst, OpenAPI_dcsf_info_t *src)
{
    cJSON *item = NULL;
    char *content = NULL;

    ogs_assert(src);
    item = OpenAPI_dcsf_info_convertToJSON(src);
    if (!item) {
        ogs_error("OpenAPI_dcsf_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_dcsf_info_free(dst);
    dst = OpenAPI_dcsf_info_parseFromJSON(item);
    cJSON_Delete(item);

    return dst;
}


Coverage Report

Created: 2026-08-17 06:12

Line	Count	Source
1
2		#include <stdlib.h>
3		#include <string.h>
4		#include <stdio.h>
5		#include "dcsf_info.h"
6
7		OpenAPI_dcsf_info_t *OpenAPI_dcsf_info_create(
8		OpenAPI_list_t *ims_domain_name_list,
9		OpenAPI_list_t *imsi_ranges,
10		OpenAPI_list_t *ims_private_identity_ranges,
11		OpenAPI_list_t *ims_public_identity_ranges,
12		OpenAPI_list_t *msisdn_ranges
13		)
14	4.81k	{
15	4.81k	OpenAPI_dcsf_info_t *dcsf_info_local_var = ogs_malloc(sizeof(OpenAPI_dcsf_info_t));
16	4.81k	ogs_assert(dcsf_info_local_var);
17
18	4.81k	dcsf_info_local_var->ims_domain_name_list = ims_domain_name_list;
19	4.81k	dcsf_info_local_var->imsi_ranges = imsi_ranges;
20	4.81k	dcsf_info_local_var->ims_private_identity_ranges = ims_private_identity_ranges;
21	4.81k	dcsf_info_local_var->ims_public_identity_ranges = ims_public_identity_ranges;
22	4.81k	dcsf_info_local_var->msisdn_ranges = msisdn_ranges;
23
24	4.81k	return dcsf_info_local_var;
25	4.81k	}
26
27		void OpenAPI_dcsf_info_free(OpenAPI_dcsf_info_t *dcsf_info)
28	8.82k	{
29	8.82k	OpenAPI_lnode_t *node = NULL;
30
31	8.82k	if (NULL == dcsf_info) {
32	4.01k	return;
33	4.01k	}
34	4.81k	if (dcsf_info->ims_domain_name_list) {
35	582	OpenAPI_list_for_each(dcsf_info->ims_domain_name_list, node) {
36	582	ogs_free(node->data);
37	582	}
38	396	OpenAPI_list_free(dcsf_info->ims_domain_name_list);
39	396	dcsf_info->ims_domain_name_list = NULL;
40	396	}
41	4.81k	if (dcsf_info->imsi_ranges) {
42	1.25k	OpenAPI_list_for_each(dcsf_info->imsi_ranges, node) {
43	1.25k	OpenAPI_imsi_range_free(node->data);
44	1.25k	}
45	420	OpenAPI_list_free(dcsf_info->imsi_ranges);
46	420	dcsf_info->imsi_ranges = NULL;
47	420	}
48	4.81k	if (dcsf_info->ims_private_identity_ranges) {
49	397	OpenAPI_list_for_each(dcsf_info->ims_private_identity_ranges, node) {
50	297	OpenAPI_identity_range_free(node->data);
51	297	}
52	397	OpenAPI_list_free(dcsf_info->ims_private_identity_ranges);
53	397	dcsf_info->ims_private_identity_ranges = NULL;
54	397	}
55	4.81k	if (dcsf_info->ims_public_identity_ranges) {
56	396	OpenAPI_list_for_each(dcsf_info->ims_public_identity_ranges, node) {
57	396	OpenAPI_identity_range_free(node->data);
58	396	}
59	396	OpenAPI_list_free(dcsf_info->ims_public_identity_ranges);
60	396	dcsf_info->ims_public_identity_ranges = NULL;
61	396	}
62	4.81k	if (dcsf_info->msisdn_ranges) {
63	338	OpenAPI_list_for_each(dcsf_info->msisdn_ranges, node) {
64	338	OpenAPI_identity_range_free(node->data);
65	338	}
66	269	OpenAPI_list_free(dcsf_info->msisdn_ranges);
67	269	dcsf_info->msisdn_ranges = NULL;
68	269	}
69	4.81k	ogs_free(dcsf_info);
70	4.81k	}
71
72		cJSON OpenAPI_dcsf_info_convertToJSON(OpenAPI_dcsf_info_t dcsf_info)
73	0	{
74	0	cJSON *item = NULL;
75	0	OpenAPI_lnode_t *node = NULL;
76
77	0	if (dcsf_info == NULL) {
78	0	ogs_error("OpenAPI_dcsf_info_convertToJSON() failed [DcsfInfo]");
79	0	return NULL;
80	0	}
81
82	0	item = cJSON_CreateObject();
83	0	if (dcsf_info->ims_domain_name_list) {
84	0	cJSON *ims_domain_name_listList = cJSON_AddArrayToObject(item, "imsDomainNameList");
85	0	if (ims_domain_name_listList == NULL) {
86	0	ogs_error("OpenAPI_dcsf_info_convertToJSON() failed [ims_domain_name_list]");
87	0	goto end;
88	0	}
89	0	OpenAPI_list_for_each(dcsf_info->ims_domain_name_list, node) {
90	0	if (cJSON_AddStringToObject(ims_domain_name_listList, "", (char*)node->data) == NULL) {
91	0	ogs_error("OpenAPI_dcsf_info_convertToJSON() failed [ims_domain_name_list]");
92	0	goto end;
93	0	}
94	0	}
95	0	}
96
97	0	if (dcsf_info->imsi_ranges) {
98	0	cJSON *imsi_rangesList = cJSON_AddArrayToObject(item, "imsiRanges");
99	0	if (imsi_rangesList == NULL) {
100	0	ogs_error("OpenAPI_dcsf_info_convertToJSON() failed [imsi_ranges]");
101	0	goto end;
102	0	}
103	0	OpenAPI_list_for_each(dcsf_info->imsi_ranges, node) {
104	0	cJSON *itemLocal = OpenAPI_imsi_range_convertToJSON(node->data);
105	0	if (itemLocal == NULL) {
106	0	ogs_error("OpenAPI_dcsf_info_convertToJSON() failed [imsi_ranges]");
107	0	goto end;
108	0	}
109	0	cJSON_AddItemToArray(imsi_rangesList, itemLocal);
110	0	}
111	0	}
112
113	0	if (dcsf_info->ims_private_identity_ranges) {
114	0	cJSON *ims_private_identity_rangesList = cJSON_AddArrayToObject(item, "imsPrivateIdentityRanges");
115	0	if (ims_private_identity_rangesList == NULL) {
116	0	ogs_error("OpenAPI_dcsf_info_convertToJSON() failed [ims_private_identity_ranges]");
117	0	goto end;
118	0	}
119	0	OpenAPI_list_for_each(dcsf_info->ims_private_identity_ranges, node) {
120	0	cJSON *itemLocal = OpenAPI_identity_range_convertToJSON(node->data);
121	0	if (itemLocal == NULL) {
122	0	ogs_error("OpenAPI_dcsf_info_convertToJSON() failed [ims_private_identity_ranges]");
123	0	goto end;
124	0	}
125	0	cJSON_AddItemToArray(ims_private_identity_rangesList, itemLocal);
126	0	}
127	0	}
128
129	0	if (dcsf_info->ims_public_identity_ranges) {
130	0	cJSON *ims_public_identity_rangesList = cJSON_AddArrayToObject(item, "imsPublicIdentityRanges");
131	0	if (ims_public_identity_rangesList == NULL) {
132	0	ogs_error("OpenAPI_dcsf_info_convertToJSON() failed [ims_public_identity_ranges]");
133	0	goto end;
134	0	}
135	0	OpenAPI_list_for_each(dcsf_info->ims_public_identity_ranges, node) {
136	0	cJSON *itemLocal = OpenAPI_identity_range_convertToJSON(node->data);
137	0	if (itemLocal == NULL) {
138	0	ogs_error("OpenAPI_dcsf_info_convertToJSON() failed [ims_public_identity_ranges]");
139	0	goto end;
140	0	}
141	0	cJSON_AddItemToArray(ims_public_identity_rangesList, itemLocal);
142	0	}
143	0	}
144
145	0	if (dcsf_info->msisdn_ranges) {
146	0	cJSON *msisdn_rangesList = cJSON_AddArrayToObject(item, "msisdnRanges");
147	0	if (msisdn_rangesList == NULL) {
148	0	ogs_error("OpenAPI_dcsf_info_convertToJSON() failed [msisdn_ranges]");
149	0	goto end;
150	0	}
151	0	OpenAPI_list_for_each(dcsf_info->msisdn_ranges, node) {
152	0	cJSON *itemLocal = OpenAPI_identity_range_convertToJSON(node->data);
153	0	if (itemLocal == NULL) {
154	0	ogs_error("OpenAPI_dcsf_info_convertToJSON() failed [msisdn_ranges]");
155	0	goto end;
156	0	}
157	0	cJSON_AddItemToArray(msisdn_rangesList, itemLocal);
158	0	}
159	0	}
160
161	0	end:
162	0	return item;
163	0	}
164
165		OpenAPI_dcsf_info_t OpenAPI_dcsf_info_parseFromJSON(cJSON dcsf_infoJSON)
166	8.23k	{
167	8.23k	OpenAPI_dcsf_info_t *dcsf_info_local_var = NULL;
168	8.23k	OpenAPI_lnode_t *node = NULL;
169	8.23k	cJSON *ims_domain_name_list = NULL;
170	8.23k	OpenAPI_list_t *ims_domain_name_listList = NULL;
171	8.23k	cJSON *imsi_ranges = NULL;
172	8.23k	OpenAPI_list_t *imsi_rangesList = NULL;
173	8.23k	cJSON *ims_private_identity_ranges = NULL;
174	8.23k	OpenAPI_list_t *ims_private_identity_rangesList = NULL;
175	8.23k	cJSON *ims_public_identity_ranges = NULL;
176	8.23k	OpenAPI_list_t *ims_public_identity_rangesList = NULL;
177	8.23k	cJSON *msisdn_ranges = NULL;
178	8.23k	OpenAPI_list_t *msisdn_rangesList = NULL;
179	8.23k	ims_domain_name_list = cJSON_GetObjectItemCaseSensitive(dcsf_infoJSON, "imsDomainNameList");
180	8.23k	if (ims_domain_name_list) {
181	1.01k	cJSON *ims_domain_name_list_local = NULL;
182	1.01k	if (!cJSON_IsArray(ims_domain_name_list)) {
183	226	ogs_error("OpenAPI_dcsf_info_parseFromJSON() failed [ims_domain_name_list]");
184	226	goto end;
185	226	}
186
187	793	ims_domain_name_listList = OpenAPI_list_create();
188
189	1.50k	cJSON_ArrayForEach(ims_domain_name_list_local, ims_domain_name_list) {
190	1.50k	double *localDouble = NULL;
191	1.50k	int *localInt = NULL;
192	1.50k	if (!cJSON_IsString(ims_domain_name_list_local)) {
193	397	ogs_error("OpenAPI_dcsf_info_parseFromJSON() failed [ims_domain_name_list]");
194	397	goto end;
195	397	}
196	1.10k	OpenAPI_list_add(ims_domain_name_listList, ogs_strdup(ims_domain_name_list_local->valuestring));
197	1.10k	}
198	793	}
199
200	7.61k	imsi_ranges = cJSON_GetObjectItemCaseSensitive(dcsf_infoJSON, "imsiRanges");
201	7.61k	if (imsi_ranges) {
202	1.02k	cJSON *imsi_ranges_local = NULL;
203	1.02k	if (!cJSON_IsArray(imsi_ranges)) {
204	66	ogs_error("OpenAPI_dcsf_info_parseFromJSON() failed [imsi_ranges]");
205	66	goto end;
206	66	}
207
208	961	imsi_rangesList = OpenAPI_list_create();
209
210	2.26k	cJSON_ArrayForEach(imsi_ranges_local, imsi_ranges) {
211	2.26k	if (!cJSON_IsObject(imsi_ranges_local)) {
212	404	ogs_error("OpenAPI_dcsf_info_parseFromJSON() failed [imsi_ranges]");
213	404	goto end;
214	404	}
215	1.85k	OpenAPI_imsi_range_t *imsi_rangesItem = OpenAPI_imsi_range_parseFromJSON(imsi_ranges_local);
216	1.85k	if (!imsi_rangesItem) {
217	137	ogs_error("No imsi_rangesItem");
218	137	goto end;
219	137	}
220	1.72k	OpenAPI_list_add(imsi_rangesList, imsi_rangesItem);
221	1.72k	}
222	961	}
223
224	7.00k	ims_private_identity_ranges = cJSON_GetObjectItemCaseSensitive(dcsf_infoJSON, "imsPrivateIdentityRanges");
225	7.00k	if (ims_private_identity_ranges) {
226	1.09k	cJSON *ims_private_identity_ranges_local = NULL;
227	1.09k	if (!cJSON_IsArray(ims_private_identity_ranges)) {
228	196	ogs_error("OpenAPI_dcsf_info_parseFromJSON() failed [ims_private_identity_ranges]");
229	196	goto end;
230	196	}
231
232	902	ims_private_identity_rangesList = OpenAPI_list_create();
233
234	1.22k	cJSON_ArrayForEach(ims_private_identity_ranges_local, ims_private_identity_ranges) {
235	1.22k	if (!cJSON_IsObject(ims_private_identity_ranges_local)) {
236	438	ogs_error("OpenAPI_dcsf_info_parseFromJSON() failed [ims_private_identity_ranges]");
237	438	goto end;
238	438	}
239	787	OpenAPI_identity_range_t *ims_private_identity_rangesItem = OpenAPI_identity_range_parseFromJSON(ims_private_identity_ranges_local);
240	787	if (!ims_private_identity_rangesItem) {
241	67	ogs_error("No ims_private_identity_rangesItem");
242	67	goto end;
243	67	}
244	720	OpenAPI_list_add(ims_private_identity_rangesList, ims_private_identity_rangesItem);
245	720	}
246	902	}
247
248	6.30k	ims_public_identity_ranges = cJSON_GetObjectItemCaseSensitive(dcsf_infoJSON, "imsPublicIdentityRanges");
249	6.30k	if (ims_public_identity_ranges) {
250	1.09k	cJSON *ims_public_identity_ranges_local = NULL;
251	1.09k	if (!cJSON_IsArray(ims_public_identity_ranges)) {
252	210	ogs_error("OpenAPI_dcsf_info_parseFromJSON() failed [ims_public_identity_ranges]");
253	210	goto end;
254	210	}
255
256	884	ims_public_identity_rangesList = OpenAPI_list_create();
257
258	1.22k	cJSON_ArrayForEach(ims_public_identity_ranges_local, ims_public_identity_ranges) {
259	1.22k	if (!cJSON_IsObject(ims_public_identity_ranges_local)) {
260	422	ogs_error("OpenAPI_dcsf_info_parseFromJSON() failed [ims_public_identity_ranges]");
261	422	goto end;
262	422	}
263	803	OpenAPI_identity_range_t *ims_public_identity_rangesItem = OpenAPI_identity_range_parseFromJSON(ims_public_identity_ranges_local);
264	803	if (!ims_public_identity_rangesItem) {
265	66	ogs_error("No ims_public_identity_rangesItem");
266	66	goto end;
267	66	}
268	737	OpenAPI_list_add(ims_public_identity_rangesList, ims_public_identity_rangesItem);
269	737	}
270	884	}
271
272	5.60k	msisdn_ranges = cJSON_GetObjectItemCaseSensitive(dcsf_infoJSON, "msisdnRanges");
273	5.60k	if (msisdn_ranges) {
274	1.06k	cJSON *msisdn_ranges_local = NULL;
275	1.06k	if (!cJSON_IsArray(msisdn_ranges)) {
276	204	ogs_error("OpenAPI_dcsf_info_parseFromJSON() failed [msisdn_ranges]");
277	204	goto end;
278	204	}
279
280	860	msisdn_rangesList = OpenAPI_list_create();
281
282	1.32k	cJSON_ArrayForEach(msisdn_ranges_local, msisdn_ranges) {
283	1.32k	if (!cJSON_IsObject(msisdn_ranges_local)) {
284	397	ogs_error("OpenAPI_dcsf_info_parseFromJSON() failed [msisdn_ranges]");
285	397	goto end;
286	397	}
287	931	OpenAPI_identity_range_t *msisdn_rangesItem = OpenAPI_identity_range_parseFromJSON(msisdn_ranges_local);
288	931	if (!msisdn_rangesItem) {
289	194	ogs_error("No msisdn_rangesItem");
290	194	goto end;
291	194	}
292	737	OpenAPI_list_add(msisdn_rangesList, msisdn_rangesItem);
293	737	}
294	860	}
295
296	4.81k	dcsf_info_local_var = OpenAPI_dcsf_info_create (
297	4.81k	ims_domain_name_list ? ims_domain_name_listList : NULL,
298	4.81k	imsi_ranges ? imsi_rangesList : NULL,
299	4.81k	ims_private_identity_ranges ? ims_private_identity_rangesList : NULL,
300	4.81k	ims_public_identity_ranges ? ims_public_identity_rangesList : NULL,
301	4.81k	msisdn_ranges ? msisdn_rangesList : NULL
302	4.81k	);
303
304	4.81k	return dcsf_info_local_var;
305	3.42k	end:
306	3.42k	if (ims_domain_name_listList) {
307	526	OpenAPI_list_for_each(ims_domain_name_listList, node) {
308	526	ogs_free(node->data);
309	526	}
310	397	OpenAPI_list_free(ims_domain_name_listList);
311	397	ims_domain_name_listList = NULL;
312	397	}
313	3.42k	if (imsi_rangesList) {
314	541	OpenAPI_list_for_each(imsi_rangesList, node) {
315	465	OpenAPI_imsi_range_free(node->data);
316	465	}
317	541	OpenAPI_list_free(imsi_rangesList);
318	541	imsi_rangesList = NULL;
319	541	}
320	3.42k	if (ims_private_identity_rangesList) {
321	505	OpenAPI_list_for_each(ims_private_identity_rangesList, node) {
322	423	OpenAPI_identity_range_free(node->data);
323	423	}
324	505	OpenAPI_list_free(ims_private_identity_rangesList);
325	505	ims_private_identity_rangesList = NULL;
326	505	}
327	3.42k	if (ims_public_identity_rangesList) {
328	488	OpenAPI_list_for_each(ims_public_identity_rangesList, node) {
329	341	OpenAPI_identity_range_free(node->data);
330	341	}
331	488	OpenAPI_list_free(ims_public_identity_rangesList);
332	488	ims_public_identity_rangesList = NULL;
333	488	}
334	3.42k	if (msisdn_rangesList) {
335	591	OpenAPI_list_for_each(msisdn_rangesList, node) {
336	399	OpenAPI_identity_range_free(node->data);
337	399	}
338	591	OpenAPI_list_free(msisdn_rangesList);
339	591	msisdn_rangesList = NULL;
340	591	}
341	3.42k	return NULL;
342	5.60k	}
343
344		OpenAPI_dcsf_info_t OpenAPI_dcsf_info_copy(OpenAPI_dcsf_info_t dst, OpenAPI_dcsf_info_t *src)
345	0	{
346	0	cJSON *item = NULL;
347	0	char *content = NULL;
348
349	0	ogs_assert(src);
350	0	item = OpenAPI_dcsf_info_convertToJSON(src);
351	0	if (!item) {
352	0	ogs_error("OpenAPI_dcsf_info_convertToJSON() failed");
353	0	return NULL;
354	0	}
355
356	0	content = cJSON_Print(item);
357	0	cJSON_Delete(item);
358
359	0	if (!content) {
360	0	ogs_error("cJSON_Print() failed");
361	0	return NULL;
362	0	}
363
364	0	item = cJSON_Parse(content);
365	0	ogs_free(content);
366	0	if (!item) {
367	0	ogs_error("cJSON_Parse() failed");
368	0	return NULL;
369	0	}
370
371	0	OpenAPI_dcsf_info_free(dst);
372	0	dst = OpenAPI_dcsf_info_parseFromJSON(item);
373	0	cJSON_Delete(item);
374
375	0	return dst;
376	0	}
377