MI_Result Field_Construct()

in Unix/base/field.c [176:446]

• 246 lines of code
• 51 McCabe index (conditional complexity)

MI_Result Field_Construct(
    Field* self,
    MI_Type type,
    const MI_Value* value,
    MI_Uint32 flags,
    Batch* batch)
{
    MI_Result r;

    /* Zero out self */
    _Fill(self, type, 0);

    /* Handle null case up front */
    if (flags & MI_FLAG_NULL)
        MI_RETURN(MI_RESULT_OK);

    /* Reject null values */
    /* ATTN: Tolerate this for now */
    if (!value)
        MI_RETURN(MI_RESULT_OK);

    switch (type)
    {
        case MI_BOOLEAN:
        {
            self->boolean.value = value->boolean;
            self->boolean.exists = MI_TRUE;
            break;
        }
        case MI_UINT8:
        {
            self->uint8.value = value->uint8;
            self->uint8.exists = MI_TRUE;
            break;
        }
        case MI_SINT8:
        {
            self->sint8.value = value->sint8;
            self->sint8.exists = MI_TRUE;
            break;
        }
        case MI_UINT16:
        {
            self->uint16.value = value->uint16;
            self->uint16.exists = MI_TRUE;
            break;
        }
        case MI_SINT16:
        {
            self->sint16.value = value->sint16;
            self->sint16.exists = MI_TRUE;
            break;
        }
        case MI_UINT32:
        {
            self->uint32.value = value->uint32;
            self->uint32.exists = MI_TRUE;
            break;
        }
        case MI_SINT32:
        {
            self->sint32.value = value->sint32;
            self->sint32.exists = MI_TRUE;
            break;
        }
        case MI_UINT64:
        {
            self->uint64.value = value->uint64;
            self->uint64.exists = MI_TRUE;
            break;
        }
        case MI_SINT64:
        {
            self->sint64.value = value->sint64;
            self->sint64.exists = MI_TRUE;
            break;
        }
        case MI_REAL32:
        {
            self->real32.value = value->real32;
            self->real32.exists = MI_TRUE;
            break;
        }
        case MI_REAL64:
        {
            self->real64.value = value->real64;
            self->real64.exists = MI_TRUE;
            break;
        }
        case MI_CHAR16:
        {
            self->char16.value = value->char16;
            self->char16.exists = MI_TRUE;
            break;
        }
        case MI_DATETIME:
        {
            self->datetime.value = value->datetime;
            self->datetime.exists = MI_TRUE;
            break;
        }
        case MI_STRING:
        {
            if (value->string)
            {
                ZChar* str;

                if (flags & MI_FLAG_BORROW)
                {
                    self->string.value = value->string;
                    self->string.exists = MI_TRUE;
                    self->string.flags = _BORROW;
                    break;
                }

                str = BStrdup(batch, value->string, CALLSITE);
                if (!str)
                    MI_RETURN(MI_RESULT_FAILED);

                self->string.value = str;
                self->string.exists = MI_TRUE;
            }
            else
            {
                self->string.value = NULL;
                self->string.exists = MI_FALSE;
                self->string.flags = 0;
            }
            break;
        }
        case MI_INSTANCE:
        case MI_REFERENCE:
        {
            if (value->instance)
            {
                MI_Instance* instance;

                if (flags & MI_FLAG_BORROW)
                {
                    self->instance.value = value->instance;
                    self->instance.exists = MI_TRUE;
                    self->instance.flags = _BORROW;
                    break;
                }

                r = Instance_Clone(value->instance, &instance, batch);
                if (r != MI_RESULT_OK)
                    MI_RETURN(r);

                self->instance.value = instance;
                self->instance.exists = MI_TRUE;
            }
            else
            {
                self->instance.value = NULL;
                self->instance.exists = MI_FALSE;
                self->instance.flags = 0;
            }
            break;
        }
        case MI_BOOLEANA:
        case MI_UINT8A:
        case MI_SINT8A:
        case MI_UINT16A:
        case MI_SINT16A:
        case MI_UINT32A:
        case MI_SINT32A:
        case MI_UINT64A:
        case MI_SINT64A:
        case MI_REAL32A:
        case MI_REAL64A:
        case MI_CHAR16A:
        case MI_DATETIMEA:
        {
            if (value->array.data)
            {
                void* data;

                if (flags & MI_FLAG_BORROW)
                {
                    self->array.value = value->array;
                    self->array.exists = MI_TRUE;
                    self->array.flags = _BORROW;;
                    break;
                }

                data = _CloneSimpleArray(
                    value->array.data, value->array.size, type, batch);

                if ((value->array.size != 0) && !data)
                    MI_RETURN(MI_RESULT_FAILED);

                self->array.value.data = data;
                self->array.value.size = value->array.size;
                self->array.exists = MI_TRUE;
            }
            else
            {
                self->array.value.data = NULL;
                self->array.value.size = 0;
                self->array.exists = MI_TRUE;
            }
            break;
        }
        case MI_STRINGA:
        {
            ZChar** data;

            if (value->array.data)
            {
                if (flags & MI_FLAG_BORROW)
                {
                    self->stringa.value = value->stringa;
                    self->stringa.exists = MI_TRUE;
                    self->stringa.flags = _BORROW;;
                    break;
                }

                data = CloneStringArray((const ZChar**)value->stringa.data,
                    value->stringa.size, batch);
                if (!data)
                    MI_RETURN(MI_RESULT_FAILED);

                self->stringa.value.data = data;
                self->stringa.value.size = value->array.size;
                self->stringa.exists = MI_TRUE;
            }
            else
            {
                self->stringa.value.data = NULL;
                self->stringa.value.size = 0;
                self->stringa.exists = MI_TRUE;
            }
            break;
        }
        case MI_INSTANCEA:
        case MI_REFERENCEA:
        {
            if (value->instancea.data)
            {
                MI_Instance** data;

                if (flags & MI_FLAG_BORROW)
                {
                    self->instancea.value = value->instancea;
                    self->instancea.exists = MI_TRUE;
                    self->instancea.flags = _BORROW;;
                    break;
                }

                data = _CloneInstanceArray(value->instancea.data,
                    value->instancea.size, batch);
                if (!data)
                    MI_RETURN(MI_RESULT_FAILED);

                self->instancea.value.data = data;
                self->instancea.value.size = value->array.size;
                self->instancea.exists = MI_TRUE;
            }
            else
            {
                self->instancea.value.data = NULL;
                self->instancea.value.size = 0;
                self->instancea.exists = MI_TRUE;
            }
            break;
        }
    }

    return MI_RESULT_OK;
}