C++ (Cpp) Instance_New示例

示例#1

文件： Utils.cpp 项目： alinbalutoiu/PyMI

PyObject* MI2Py(const MI_Value& value, MI_Type valueType, MI_Uint32 flags)
{
    if (flags & MI_FLAG_NULL)
        Py_RETURN_NONE;

    if (valueType & MI_ARRAY)
    {
        return MIArray2PyTuple(value, (MI_Type)(valueType ^ MI_ARRAY));
    }

    switch (valueType)
    {
    case MI_BOOLEAN:
        return PyBool_FromLong(value.boolean);
    case MI_SINT8:
        return PyLong_FromLong(value.sint8);
    case MI_UINT8:
        return PyLong_FromUnsignedLong(value.uint8);
    case MI_SINT16:
        return PyLong_FromLong(value.sint16);
    case MI_UINT16:
        return PyLong_FromUnsignedLong(value.uint16);
    case MI_SINT32:
        return PyLong_FromLong(value.sint32);
    case MI_UINT32:
        return PyLong_FromUnsignedLong(value.uint32);
    case MI_SINT64:
        return PyLong_FromLongLong(value.sint64);
    case MI_UINT64:
        return PyLong_FromUnsignedLongLong(value.uint64);
    case MI_REAL32:
        return PyFloat_FromDouble(value.real32);
    case MI_REAL64:
        return PyFloat_FromDouble(value.real64);
    case MI_CHAR16:
        return PyLong_FromLong(value.char16);
    case MI_DATETIME:
        // TODO: understand where this import needs to be called
        PyDateTime_IMPORT;
        if (value.datetime.isTimestamp)
        {
            const MI_Timestamp& ts = value.datetime.u.timestamp;
            // TODO: Add timezone support!
            return PyDateTime_FromDateAndTime(ts.year, ts.month, ts.day, ts.hour, ts.minute, ts.second, ts.microseconds);
        }
        else
        {
            return PyDeltaFromMIInterval(value.datetime.u.interval);
        }
        break;
    case MI_STRING:
        return PyUnicode_FromWideChar(value.string, wcslen(value.string));
    case MI_INSTANCE:
        return (PyObject*)Instance_New(std::make_shared<MI::Instance>(value.instance, false));
    case MI_REFERENCE:
        return (PyObject*)Instance_New(std::make_shared<MI::Instance>(value.reference, false));
    default:
        throw MI::TypeConversionException();
    }
}

示例#2

文件： NativeResourceHostMiContext.c 项目： Microsoft/PowerShell-DSC-for-Linux

static MI_Result NewParameters(_In_ MI_Context* context, _In_ const MI_MethodDecl* methodDecl, MI_Instance** instance)
{
    #if defined(_MSC_VER)
    return Instance_New((MI_ClassDecl*)methodDecl, instance);
    #else
    return Instance_New(instance, (MI_ClassDecl*)methodDecl, NULL);
    #endif
}

示例#3

文件： NativeResourceHostMiContext.c 项目： Microsoft/PowerShell-DSC-for-Linux

static MI_Result NewInstance(_In_ MI_Context* context, _In_ const MI_ClassDecl* classDecl, MI_Instance** instance)
{
    #if defined(_MSC_VER)
    return Instance_New(classDecl, instance);
    #else
    return Instance_New(instance, classDecl, NULL);
    #endif
}

示例#4

文件： Application.cpp 项目： bclau/PyMI

static PyObject* Application_NewMethodInboundParameters(Application *self, PyObject *args, PyObject *kwds)
{
    PyObject* pyClass = NULL;
    wchar_t* methodName = NULL;

    static char *kwlist[] = { "mi_class", "method_name", NULL };
    if (!PyArg_ParseTupleAndKeywords(args, kwds, "Ou", kwlist, &pyClass, &methodName))
        return NULL;

    try
    {
        if (!PyObject_IsInstance(pyClass, reinterpret_cast<PyObject*>(&ClassType)))
            throw MI::TypeConversionException(L"\"mi_class\" must have type Class");

        std::shared_ptr<MI::Instance> instance;
        AllowThreads(&self->cs, [&]() {
            instance = self->app->NewMethodParamsInstance(*((Class*)pyClass)->miClass, methodName);
        });
        return (PyObject*)Instance_New(instance);
    }
    catch (std::exception& ex)
    {
        SetPyException(ex);
        return NULL;
    }
}

示例#5

文件： Application.cpp 项目： bclau/PyMI

static PyObject* Application_NewInstanceFromClass(Application *self, PyObject *args, PyObject *kwds)
{
    wchar_t* className = NULL;
    PyObject* miClass = NULL;
    static char *kwlist[] = { "class_name", "mi_class", NULL };
    if (!PyArg_ParseTupleAndKeywords(args, kwds, "uO", kwlist, &className, &miClass))
        return NULL;

    try
    {
        if (!PyObject_IsInstance(miClass, reinterpret_cast<PyObject*>(&ClassType)))
            throw MI::TypeConversionException(L"\"mi_class\" must have type Class");

        std::shared_ptr<MI::Instance> instance;
        AllowThreads(&self->cs, [&]() {
            instance = self->app->NewInstanceFromClass(className, *((Class*)miClass)->miClass);
        });
        return (PyObject*)Instance_New(instance);
    }
    catch (std::exception& ex)
    {
        SetPyException(ex);
        return NULL;
    }
}

示例#6

文件： instanceutil.c 项目： Diastro/PowerShell-DSC-for-Linux

_Use_decl_annotations_
MI_Result MI_CALL Mof_Instance_New(
    const MI_ClassDecl* classDecl,
    MI_Instance **instance)
{
    return Instance_New(classDecl, instance);
}

示例#7

文件： Operation.cpp 项目： bclau/PyMI

static PyObject* Operation_GetNextIndication(Operation* self, PyObject*)
{
    try
    {
        std::shared_ptr<MI::Instance> instance;
        AllowThreads(&self->cs, [&]() {
            instance = self->operation->GetNextIndication();
        });
        if (instance)
        {
            return (PyObject*)Instance_New(instance);
        }
        Py_RETURN_NONE;
    }
    catch (std::exception& ex)
    {
        SetPyException(ex);
        return NULL;
    }
}

示例#8

文件： Application.cpp 项目： bclau/PyMI

static PyObject* Application_NewInstance(Application *self, PyObject *args, PyObject *kwds)
{
    wchar_t* className = NULL;
    static char *kwlist[] = { "class_name", NULL };
    if (!PyArg_ParseTupleAndKeywords(args, kwds, "u", kwlist, &className))
        return NULL;

    try
    {
        std::shared_ptr<MI::Instance> instance;
        AllowThreads(&self->cs, [&]() {
            instance = self->app->NewInstance(className);
        });
        return (PyObject*)Instance_New(instance);
    }
    catch (std::exception& ex)
    {
        SetPyException(ex);
        return NULL;
    }
}