// Generated by genprov 1.0.21
#include "All_Class_Provider.h"

/*
    Provides a single class, the All_Class that attempts to include all
    CIMTypes to confirm the ability to create, modify, and get all of
    the data types transparently.
 
    TODO: Convert this to use instance_map
*/

CIMPLE_NAMESPACE_BEGIN

All_Class_Provider::All_Class_Provider() : _instance(0)
{
}

All_Class_Provider::~All_Class_Provider()
{
}

Load_Status All_Class_Provider::load()
{
    CIMPLE_DBG(("Load"));
    return LOAD_OK;
}

Unload_Status All_Class_Provider::unload()
{
    if (_instance)
        unref(_instance);
    return UNLOAD_OK;
}

Get_Instance_Status All_Class_Provider::get_instance(
    const All_Class* model,
    All_Class*& instance)
{
    CIMPLE_DBG(("get_instance key = %u", model->Key.value));

    if (_instance == 0)
    {
        return GET_INSTANCE_NOT_FOUND;
    }
    if ((key_eq(model, _instance)))
    {
        instance = _instance->clone();
//        printf("GetInstance - Saved Instance\n");
//        print(_instance);
//        printf("GetInstance - Clone of Saved Instance\n");
//        print(instance);
//        printf("GetInstance - model\n");
//        print(model);

        //assert(_instance == instance);
        return GET_INSTANCE_OK;
    }
    return GET_INSTANCE_NOT_FOUND;
}

// Note that the enum_instances operation returns a set of
// instances that are completely different than the create and delete
// use.
// ATTN: Need to add this as a test on client
Enum_Instances_Status All_Class_Provider::enum_instances(
    const All_Class* model,
    Enum_Instances_Handler<All_Class>* handler)
{
    CIMPLE_DBG(("enum_instances"));

    // This test returns a single predefined instance
    All_Class* inst = All_Class::create(true);
    inst->Key.set(99);
    inst->booleanScalar.set(false);
    inst->uint8Scalar.set(8);
    inst->sint8Scalar.set(-8);
    inst->uint16Scalar.set(16);
    inst->sint16Scalar.set(-16);
    inst->uint32Scalar.set(32);
    inst->sint32Scalar.set(-32);
    inst->uint64Scalar.set(64);
    inst->sint64Scalar.set(-64);
    inst->real32Scalar.set(32);
    inst->real64Scalar.set(64);
    inst->char16Scalar.set('A');
    inst->stringScalar.set("Hello");
    inst->datetimeScalar.set(Datetime("20070101120000.000000-360"));

    inst->booleanArray.set(Array<boolean>::make(true, false, true));
    inst->uint8Array.set(Array<uint8>::make(0, 8, 254));
    inst->sint8Array.set(Array<sint8>::make(-125, -8, 126));
    inst->uint16Array.set(Array<uint16>::make(819, 0, 16, 999));
    inst->sint16Array.set(Array<sint16>::make(-819, 0, 16, 999));
    inst->uint32Array.set(Array<uint32>::make(8192, 0, 16, 9999));
    inst->sint32Array.set(Array<sint32>::make(-8192, 0, 16, 15000));
    inst->uint64Array.set(Array<uint64>::make(8192, 0, 16, 9999));
    inst->sint64Array.set(Array<sint64>::make(-8192, 0, 16, 9999));
    inst->real32Array.set(Array<real32>::make(32, 32, 32));
    inst->real64Array.set(Array<real64>::make(64, 64, 64));
    inst->char16Array.set(Array<char16>::make('A', 'B', 'C'));
    inst->stringArray.set(Array<String>::make("Red", "Green", "Blue", ""));
    inst->datetimeArray.set(Array<Datetime>::make(
        Datetime("20070101120000.000000-360"),
        Datetime("20070101120000.000000-360"),
        Datetime("20070101120000.000000-360")));

    All_Part* part = All_Part::create(true);
    part->Key.set(8888);

    inst->instanceScalar = part;
    inst->objectScalar = part->clone();

    //inst->instanceArray.set(Array<CIMInstance>:make(part, part->clone()));
    //inst->objectArray.set(Array<CIMObject>:make(part, part->clone()));

    handler->handle(inst);

#if 0
    All_Part* instanceScalar;
    Instance* objectScalar;
    Property<Array_boolean> booleanArray;
    Property<Array_uint8> uint8Array;
    Property<Array_sint8> sint8Array;
    Property<Array_uint16> uint16Array;
    Property<Array_sint16> sint16Array;
    Property<Array_uint32> uint32Array;
    Property<Array_sint32> sint32Array;
    Property<Array_uint64> uint64Array;
    Property<Array_sint64> sint64Array;
    Property<Array_real32> real32Array;
    Property<Array_real64> real64Array;
    Property<Array_char16> char16Array;
    Property<Array_String> stringArray;
    Property<Array_Datetime> datetimeArray;
#endif

    return ENUM_INSTANCES_OK;
}

Create_Instance_Status All_Class_Provider::create_instance(
    All_Class* instance)
{
    assert(instance);
    CIMPLE_DBG(("create_instance key = %u", instance->Key.value));

    // save the received instance.   This
    // test assumes that there will be only a single
    // active instance and unrefs any existing instance.
    
    if (_instance)
        unref(_instance);

    _instance = instance->clone();
//  printf("Create Instance \n");
//  print(_instance);

    return CREATE_INSTANCE_OK;
}

Delete_Instance_Status All_Class_Provider::delete_instance(
    const All_Class* instance)
{
    CIMPLE_DBG(("delete_instance key = %u", instance->Key.value));

    if (_instance == 0)
    {
        return DELETE_INSTANCE_NOT_FOUND;
    }

    if((key_eq(instance, _instance)))
    {
        unref(_instance);
        _instance = 0;
        return DELETE_INSTANCE_OK;
    }
    return DELETE_INSTANCE_NOT_FOUND;
}

Modify_Instance_Status All_Class_Provider::modify_instance(
    const All_Class* model,
    const All_Class* instance)
{
    // simply substitute new instance for old

    CIMPLE_DBG(("modify_instance key = %u", instance->Key.value));

    assert(instance);
    if (_instance == 0)
    {
        return MODIFY_INSTANCE_NOT_FOUND;
    }
    if((key_eq(instance, _instance)))
    {
        unref(_instance);

        // Update the instance with the modified properties

        copy(_instance, instance, model);

        return MODIFY_INSTANCE_OK;
    }
    return MODIFY_INSTANCE_NOT_FOUND;
}

Invoke_Method_Status All_Class_Provider::booleanReturn(
    const All_Class* self,
    Property<boolean>& return_value)
{
    return_value.set(true);
    return INVOKE_METHOD_OK;
}

Invoke_Method_Status All_Class_Provider::uint8Return(
    const All_Class* self,
    Property<uint8>& return_value)
{
    return_value.set(8);
    return INVOKE_METHOD_OK;
}

Invoke_Method_Status All_Class_Provider::sint8Return(
    const All_Class* self,
    Property<sint8>& return_value)
{
    return_value.set(-8);
    return INVOKE_METHOD_OK;
}

Invoke_Method_Status All_Class_Provider::uint16Return(
    const All_Class* self,
    Property<uint16>& return_value)
{
    return_value.set(16);
    return INVOKE_METHOD_OK;
}

Invoke_Method_Status All_Class_Provider::sint16Return(
    const All_Class* self,
    Property<sint16>& return_value)
{
    return_value.set(-16);
    return INVOKE_METHOD_OK;
}

Invoke_Method_Status All_Class_Provider::uint32Return(
    const All_Class* self,
    Property<uint32>& return_value)
{
    return_value.set(32);
    return INVOKE_METHOD_OK;
}

Invoke_Method_Status All_Class_Provider::sint32Return(
    const All_Class* self,
    Property<sint32>& return_value)
{
    return_value.set(-32);
    return INVOKE_METHOD_OK;
}

Invoke_Method_Status All_Class_Provider::uint64Return(
    const All_Class* self,
    Property<uint64>& return_value)
{
    return_value.set(64);
    return INVOKE_METHOD_OK;
}

Invoke_Method_Status All_Class_Provider::sint64Return(
    const All_Class* self,
    Property<sint64>& return_value)
{
    return_value.set(-64);
    return INVOKE_METHOD_OK;
}

Invoke_Method_Status All_Class_Provider::real32Return(
    const All_Class* self,
    Property<real32>& return_value)
{
    return_value.set(32.32);
    return INVOKE_METHOD_OK;
}

Invoke_Method_Status All_Class_Provider::real64Return(
    const All_Class* self,
    Property<real64>& return_value)
{
    return_value.set(64.64);
    return INVOKE_METHOD_OK;
}

Invoke_Method_Status All_Class_Provider::char16Return(
    const All_Class* self,
    Property<char16>& return_value)
{
    return_value.set('A');
    return INVOKE_METHOD_OK;
}

Invoke_Method_Status All_Class_Provider::stringReturn(
    const All_Class* self,
    Property<String>& return_value)
{
    return_value.set("String");
    return INVOKE_METHOD_OK;
}

Invoke_Method_Status All_Class_Provider::datetimeReturn(
    const All_Class* self,
    Property<Datetime>& return_value)
{
    return_value.set(Datetime("20070101120000.000000-360"));
    return INVOKE_METHOD_OK;
}

Invoke_Method_Status All_Class_Provider::instanceReturn(
    const All_Class* self,
    All_Part*& return_value)
{
    return_value = All_Part::create();
    return_value->Key.set(8888);

    return INVOKE_METHOD_OK;
}

Invoke_Method_Status All_Class_Provider::objectReturn(
    const All_Class* self,
    Instance*& return_value)
{
    All_Part* part = All_Part::create();
    part->Key.set(7777);
    return_value = part;

    return INVOKE_METHOD_OK;
}

Invoke_Method_Status All_Class_Provider::booleanScalarParams(
    const All_Class* self,
    const Property<boolean>& p1,
    Property<boolean>& p2,
    Property<uint32>& return_value)
{
    p2 = p1;
    return_value.set(100);
    return INVOKE_METHOD_OK;
}

Invoke_Method_Status All_Class_Provider::uint8ScalarParams(
    const All_Class* self,
    const Property<uint8>& p1,
    Property<uint8>& p2,
    Property<uint32>& return_value)
{
    p2 = p1;
    return_value.set(100);
    return INVOKE_METHOD_OK;
}

Invoke_Method_Status All_Class_Provider::sint8ScalarParams(
    const All_Class* self,
    const Property<sint8>& p1,
    Property<sint8>& p2,
    Property<uint32>& return_value)
{
    p2 = p1;
    return_value.set(100);
    return INVOKE_METHOD_OK;
}

Invoke_Method_Status All_Class_Provider::uint16ScalarParams(
    const All_Class* self,
    const Property<uint16>& p1,
    Property<uint16>& p2,
    Property<uint32>& return_value)
{
    p2 = p1;
    return_value.set(100);
    return INVOKE_METHOD_OK;
}

Invoke_Method_Status All_Class_Provider::sint16ScalarParams(
    const All_Class* self,
    const Property<sint16>& p1,
    Property<sint16>& p2,
    Property<uint32>& return_value)
{
    p2 = p1;
    return_value.set(100);
    return INVOKE_METHOD_OK;
}

Invoke_Method_Status All_Class_Provider::uint32ScalarParams(
    const All_Class* self,
    const Property<uint32>& p1,
    Property<uint32>& p2,
    Property<uint32>& return_value)
{
    p2 = p1;
    return_value.set(100);
    return INVOKE_METHOD_OK;
}

Invoke_Method_Status All_Class_Provider::sint32ScalarParams(
    const All_Class* self,
    const Property<sint32>& p1,
    Property<sint32>& p2,
    Property<uint32>& return_value)
{
    p2 = p1;
    return_value.set(100);
    return INVOKE_METHOD_OK;
}

Invoke_Method_Status All_Class_Provider::uint64ScalarParams(
    const All_Class* self,
    const Property<uint64>& p1,
    Property<uint64>& p2,
    Property<uint32>& return_value)
{
    p2 = p1;
    return_value.set(100);
    return INVOKE_METHOD_OK;
}

Invoke_Method_Status All_Class_Provider::sint64ScalarParams(
    const All_Class* self,
    const Property<sint64>& p1,
    Property<sint64>& p2,
    Property<uint32>& return_value)
{
    p2 = p1;
    return_value.set(100);
    return INVOKE_METHOD_OK;
}

Invoke_Method_Status All_Class_Provider::real32ScalarParams(
    const All_Class* self,
    const Property<real32>& p1,
    Property<real32>& p2,
    Property<uint32>& return_value)
{
    p2 = p1;
    return_value.set(100);
    return INVOKE_METHOD_OK;
}

Invoke_Method_Status All_Class_Provider::real64ScalarParams(
    const All_Class* self,
    const Property<real64>& p1,
    Property<real64>& p2,
    Property<uint32>& return_value)
{
    p2 = p1;
    return_value.set(100);
    return INVOKE_METHOD_OK;
}

Invoke_Method_Status All_Class_Provider::char16ScalarParams(
    const All_Class* self,
    const Property<char16>& p1,
    Property<char16>& p2,
    Property<uint32>& return_value)
{
    p2 = p1;
    return_value.set(100);
    return INVOKE_METHOD_OK;
}

Invoke_Method_Status All_Class_Provider::stringScalarParams(
    const All_Class* self,
    const Property<String>& p1,
    Property<String>& p2,
    Property<uint32>& return_value)
{
    p2 = p1;
    return_value.set(100);
    return INVOKE_METHOD_OK;
}

Invoke_Method_Status All_Class_Provider::datetimeScalarParams(
    const All_Class* self,
    const Property<Datetime>& p1,
    Property<Datetime>& p2,
    Property<uint32>& return_value)
{
    p2 = p1;
    return_value.set(100);
    return INVOKE_METHOD_OK;
}

Invoke_Method_Status All_Class_Provider::objectScalarParams(
    const All_Class* self,
    const Instance* p1,
    Instance*& p2,
    Property<uint32>& return_value)
{
    p2 = clone(p1);
    return_value.set(100);
    return INVOKE_METHOD_OK;
}

Invoke_Method_Status All_Class_Provider::instanceScalarParams(
    const All_Class* self,
    const All_Part* p1,
    All_Part*& p2,
    Property<uint32>& return_value)
{
    p2 = p1->clone();
    return_value.set(100);
    return INVOKE_METHOD_OK;
}

Invoke_Method_Status All_Class_Provider::booleanArrayParams(
    const All_Class* self,
    const Property<Array_boolean>& p1,
    Property<Array_boolean>& p2,
    Property<uint32>& return_value)
{
    p2 = p1;
    return_value.set(100);
    return INVOKE_METHOD_OK;
}

Invoke_Method_Status All_Class_Provider::uint8ArrayParams(
    const All_Class* self,
    const Property<Array_uint8>& p1,
    Property<Array_uint8>& p2,
    Property<uint32>& return_value)
{
    p2 = p1;
    return_value.set(100);
    return INVOKE_METHOD_OK;
}

Invoke_Method_Status All_Class_Provider::sint8ArrayParams(
    const All_Class* self,
    const Property<Array_sint8>& p1,
    Property<Array_sint8>& p2,
    Property<uint32>& return_value)
{
    p2 = p1;
    return_value.set(100);
    return INVOKE_METHOD_OK;
}

Invoke_Method_Status All_Class_Provider::uint16ArrayParams(
    const All_Class* self,
    const Property<Array_uint16>& p1,
    Property<Array_uint16>& p2,
    Property<uint32>& return_value)
{
    p2 = p1;
    return_value.set(100);
    return INVOKE_METHOD_OK;
}

Invoke_Method_Status All_Class_Provider::sint16ArrayParams(
    const All_Class* self,
    const Property<Array_sint16>& p1,
    Property<Array_sint16>& p2,
    Property<uint32>& return_value)
{
    p2 = p1;
    return_value.set(100);
    return INVOKE_METHOD_OK;
}

Invoke_Method_Status All_Class_Provider::uint32ArrayParams(
    const All_Class* self,
    const Property<Array_uint32>& p1,
    Property<Array_uint32>& p2,
    Property<uint32>& return_value)
{
    p2 = p1;
    return_value.set(100);
    return INVOKE_METHOD_OK;
}

Invoke_Method_Status All_Class_Provider::sint32ArrayParams(
    const All_Class* self,
    const Property<Array_sint32>& p1,
    Property<Array_sint32>& p2,
    Property<uint32>& return_value)
{
    p2 = p1;
    return_value.set(100);
    return INVOKE_METHOD_OK;
}

Invoke_Method_Status All_Class_Provider::uint64ArrayParams(
    const All_Class* self,
    const Property<Array_uint64>& p1,
    Property<Array_uint64>& p2,
    Property<uint32>& return_value)
{
    p2 = p1;
    return_value.set(100);
    return INVOKE_METHOD_OK;
}

Invoke_Method_Status All_Class_Provider::sint64ArrayParams(
    const All_Class* self,
    const Property<Array_sint64>& p1,
    Property<Array_sint64>& p2,
    Property<uint32>& return_value)
{
    p2 = p1;
    return_value.set(100);
    return INVOKE_METHOD_OK;
}

Invoke_Method_Status All_Class_Provider::real32ArrayParams(
    const All_Class* self,
    const Property<Array_real32>& p1,
    Property<Array_real32>& p2,
    Property<uint32>& return_value)
{
    p2 = p1;
    return_value.set(100);
    return INVOKE_METHOD_OK;
}

Invoke_Method_Status All_Class_Provider::real64ArrayParams(
    const All_Class* self,
    const Property<Array_real64>& p1,
    Property<Array_real64>& p2,
    Property<uint32>& return_value)
{
    p2 = p1;
    return_value.set(100);
    return INVOKE_METHOD_OK;
}

Invoke_Method_Status All_Class_Provider::char16ArrayParams(
    const All_Class* self,
    const Property<Array_char16>& p1,
    Property<Array_char16>& p2,
    Property<uint32>& return_value)
{
    p2 = p1;
    return_value.set(100);
    return INVOKE_METHOD_OK;
}

Invoke_Method_Status All_Class_Provider::stringArrayParams(
    const All_Class* self,
    const Property<Array_String>& p1,
    Property<Array_String>& p2,
    Property<uint32>& return_value)
{
    p2 = p1;
    return_value.set(100);
    return INVOKE_METHOD_OK;
}

Invoke_Method_Status All_Class_Provider::datetimeArrayParams(
    const All_Class* self,
    const Property<Array_Datetime>& p1,
    Property<Array_Datetime>& p2,
    Property<uint32>& return_value)
{
    p2 = p1;
    return_value.set(100);
    return INVOKE_METHOD_OK;
}

Invoke_Method_Status All_Class_Provider::objectArrayParams(
    const All_Class* self,
    const Property< Array<Instance*> >& p1,
    Property< Array<Instance*> >& p2,
    Property<uint32>& return_value)
{
    for (size_t i = 0; i < p1.value.size(); i++)
        p2.value.append(clone(p1.value[i]));

    return_value.set(100);
    return INVOKE_METHOD_OK;
}

Invoke_Method_Status All_Class_Provider::instanceArrayParams(
    const All_Class* self,
    const Property< Array<All_Part*> >& p1,
    Property< Array<All_Part*> >& p2,
    Property<uint32>& return_value)
{
    for (size_t i = 0; i < p1.value.size(); i++)
        p2.value.append(p1.value[i]->clone());

    p2.null = false;

    return_value.set(100);
    return INVOKE_METHOD_OK;
}

Invoke_Method_Status All_Class_Provider::referenceScalarParams(
    const All_Class* self,
    const All_Part* p1,
    All_Part*& p2,
    Property<uint32>& return_value)

{
    p2 = p1->clone();
    return_value.set(100);
    return INVOKE_METHOD_OK;
}

Invoke_Method_Status All_Class_Provider::referenceArrayParams(
    const All_Class* self,
    const Property< Array<All_Part*> >& p1,
    Property< Array<All_Part*> >& p2,
    Property<uint32>& return_value)

{
    for (size_t i = 0; i < p1.value.size(); i++)
        p2.value.append(p1.value[i]->clone());

    p2.null = false;

    return_value.set(100);
    return INVOKE_METHOD_OK;
}

/*@END@*/

CIMPLE_NAMESPACE_END