binarystreamer.cpp

Pegasus is an open-source implementationof the DMTF CIM and WBEM standards. It is designed to be por

void BinaryStreamer::_unpackValue(
    const Buffer& in, Uint32& pos, CIMValue& x)
{
    _checkMagicByte(in, pos);

    CIMType type;
    _unpackType(in, pos, type);

    Boolean isArray;
    Packer::unpackBoolean(in, pos, isArray);

    Uint32 arraySize = 0;

    if (isArray)
        Packer::unpackSize(in, pos, arraySize);

    Boolean isNull;
    Packer::unpackBoolean(in, pos, isNull);

    if (isNull)
    {
        x = CIMValue(type, isArray, arraySize);
        return;
    }

    if (isArray)
    {
        CIMValue cimValue(type, isArray, arraySize);

        switch (type)
        {
            case CIMTYPE_BOOLEAN:
                UnpackArray<Boolean>::func(in, pos, arraySize, cimValue);
                break;

            case CIMTYPE_UINT8:
                UnpackArray<Uint8>::func(in, pos, arraySize, cimValue);
                break;

            case CIMTYPE_SINT8:
                UnpackArray<Sint8>::func(in, pos, arraySize, cimValue);
                break;

            case CIMTYPE_UINT16:
                UnpackArray<Uint16>::func(in, pos, arraySize, cimValue);
                break;

            case CIMTYPE_SINT16:
                UnpackArray<Sint16>::func(in, pos, arraySize, cimValue);
                break;

            case CIMTYPE_UINT32:
                UnpackArray<Uint32>::func(in, pos, arraySize, cimValue);
                break;

            case CIMTYPE_SINT32:
                UnpackArray<Sint32>::func(in, pos, arraySize, cimValue);
                break;

            case CIMTYPE_UINT64:
                UnpackArray<Uint64>::func(in, pos, arraySize, cimValue);
                break;

            case CIMTYPE_SINT64:
                UnpackArray<Sint64>::func(in, pos, arraySize, cimValue);
                break;

            case CIMTYPE_REAL32:
                UnpackArray<Real32>::func(in, pos, arraySize, cimValue);
                break;

            case CIMTYPE_REAL64:
                UnpackArray<Real64>::func(in, pos, arraySize, cimValue);
                break;

            case CIMTYPE_CHAR16:
                UnpackArray<Char16>::func(in, pos, arraySize, cimValue);
                break;

            case CIMTYPE_STRING:
                UnpackArray<String>::func(in, pos, arraySize, cimValue);
                break;

            case CIMTYPE_DATETIME:
                UnpackArray<CIMDateTime>::func(in, pos, arraySize, cimValue);
                break;

            case CIMTYPE_REFERENCE:
                UnpackArray<CIMObjectPath>::func(in, pos, arraySize, cimValue);
                break;

            case CIMTYPE_OBJECT:
                UnpackArray<CIMObject>::func(in, pos, arraySize, cimValue);
                break;
#ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT
            case CIMTYPE_INSTANCE:
                UnpackArray<CIMInstance>::func(in, pos, arraySize, cimValue);
                break;
#endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT
        }

        x = cimValue;
    }
    else
    {
        CIMValue cimValue(type, isArray);

        switch (type)
        {
            case CIMTYPE_BOOLEAN:
                UnpackScalar<Boolean>::func(in, pos, cimValue);
                break;

            case CIMTYPE_UINT8:
                UnpackScalar<Uint8>::func(in, pos, cimValue);
                break;

            case CIMTYPE_SINT8:
                UnpackScalar<Sint8>::func(in, pos, cimValue);
                break;

            case CIMTYPE_UINT16:
                UnpackScalar<Uint16>::func(in, pos, cimValue);
                break;

            case CIMTYPE_SINT16:
                UnpackScalar<Sint16>::func(in, pos, cimValue);
                break;

            case CIMTYPE_UINT32:
                UnpackScalar<Uint32>::func(in, pos, cimValue);
                break;

            case CIMTYPE_SINT32:
                UnpackScalar<Sint32>::func(in, pos, cimValue);
                break;

            case CIMTYPE_UINT64:
                UnpackScalar<Uint64>::func(in, pos, cimValue);
                break;

            case CIMTYPE_SINT64:
                UnpackScalar<Sint64>::func(in, pos, cimValue);
                break;

            case CIMTYPE_REAL32:
                UnpackScalar<Real32>::func(in, pos, cimValue);
                break;

            case CIMTYPE_REAL64:
                UnpackScalar<Real64>::func(in, pos, cimValue);
                break;

            case CIMTYPE_CHAR16:
                UnpackScalar<Char16>::func(in, pos, cimValue);
                break;

            case CIMTYPE_STRING:
                UnpackScalar<String>::func(in, pos, cimValue);
                break;

            case CIMTYPE_DATETIME:
                UnpackScalar<CIMDateTime>::func(in, pos, cimValue);
                break;

            case CIMTYPE_REFERENCE:
                UnpackScalar<CIMObjectPath>::func(in, pos, cimValue);
                break;

            case CIMTYPE_OBJECT:
                UnpackScalar<CIMObject>::func(in, pos, cimValue);
                break;
#ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT
            case CIMTYPE_INSTANCE:
                UnpackScalar<CIMInstance>::func(in, pos, cimValue);
                break;
#endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT
        }

        x = cimValue;
    }

    return;
}

void BinaryStreamer::_packProperty(Buffer& out, const CIMProperty& x)
{
    CIMPropertyRep* rep = x._rep;

    _packMagicByte(out);
    _packName(out, rep->getName());
    _packValue(out, rep->getValue());
    Packer::packSize(out, rep->getArraySize());
    _packName(out, rep->getReferenceClassName());
    _packName(out, rep->getClassOrigin());
    Packer::packBoolean(out, rep->getPropagated());
    PackQualifiers<CIMPropertyRep>::func(out, rep);
}

void BinaryStreamer::_unpackProperty(
    const Buffer& in, Uint32& pos, CIMProperty& x)
{
    _checkMagicByte(in, pos);

    CIMName name;
    _unpackName(in, pos, name);

    CIMValue value;
    _unpackValue(in, pos, value);

    Uint32 arraySize;
    Packer::unpackSize(in, pos, arraySize);

    CIMName referenceClassName;
    _unpackName(in, pos, referenceClassName);

    CIMName classOrigin;
    _unpackName(in, pos, classOrigin);

    Boolean propagated;
    Packer::unpackBoolean(in, pos, propagated);

    CIMProperty cimProperty(
        name, value, arraySize, referenceClassName, classOrigin, propagated);

    UnpackQualifiers<CIMProperty>::func(in, pos, cimProperty);
#ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT
    if (cimProperty.getType() == CIMTYPE_STRING)
    {
        CIMType realType = CIMTYPE_STRING;
        if (cimProperty.findQualifier("EmbeddedInstance") != PEG_NOT_FOUND)
        {
            // Note that this condition should only happen for properties in
            // class definitions, and only NULL values are recognized. We
            // currently don't handle embedded instance types with default
            // values in the class definition.
            PEGASUS_ASSERT(value.isNull());
            realType = CIMTYPE_INSTANCE;
        }
        else if (cimProperty.findQualifier("EmbeddedObject") != PEG_NOT_FOUND)
        {
            // Note that this condition should only happen for properties in
            // class definitions, and only NULL values are recognized. We
            // currently don't handle embedded object types with default
            // values in the class definition.
            PEGASUS_ASSERT(value.isNull());
            realType = CIMTYPE_OBJECT;
        }

        if (realType != CIMTYPE_STRING)
        {
            CIMProperty tmpProperty(name, CIMValue(realType, value.isArray()),
                arraySize, referenceClassName, classOrigin, propagated);
            for (unsigned int i = 0, n = cimProperty.getQualifierCount();
                 i < n; ++i)
            {
                tmpProperty.addQualifier(cimProperty.getQualifier(i));
            }
            cimProperty = tmpProperty;
        }
    }
#endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT
    x = cimProperty;
}

void BinaryStreamer::_packParameter(Buffer& out, const CIMParameter& x)
{
    CIMParameterRep* rep = x._rep;

    _packMagicByte(out);
    _packName(out, rep->getName());
    _packType(out, rep->getType());
    Packer::packBoolean(out, rep->isArray());
    Packer::packSize(out, rep->getArraySize());
    _packName(out, rep->getReferenceClassName());
    PackQualifiers<CIMParameterRep>::func(out, rep);
}

void BinaryStreamer::_unpackParameter(
    const Buffer& in, Uint32& pos, CIMParameter& x)
{
    _checkMagicByte(in, pos);

    CIMName name;
    _unpackName(in, pos, name);

    CIMType type;
    _unpackType(in, pos, type);

    Boolean isArray;
    Packer::unpackBoolean(in, pos, isArray);

    Uint32 arraySize;
    Packer::unpackSize(in, pos, arraySize);

    CIMName referenceClassName;
    _unpackName(in, pos, referenceClassName);

    CIMParameter cimParameter(
        name, type, isArray, arraySize, referenceClassName);

    UnpackQualifiers<CIMParameter>::func(in, pos, cimParameter);

    x = cimParameter;
}

void BinaryStreamer::_packParameters(Buffer& out, CIMMethodRep* rep)
{
    Uint32 n = rep->getParameterCount();
    Packer::packSize(out, n);

    for (Uint32 i = 0; i < n; i++)
        BinaryStreamer::_packParameter(out, rep->getParameter(i));
}

void BinaryStreamer::_unpackParameters(
    const Buffer& in, Uint32& pos, CIMMethod& x)
{
    Uint32 n;
    Packer::unpackSize(in, pos, n);

    for (size_t i = 0; i < n; i++)
    {
        CIMParameter q;
        _unpackParameter(in, pos, q);
        x.addParameter(q);
    }
}

void BinaryStreamer::_packMethod(Buffer& out, const CIMMethod& x)
{
    CIMMethodRep* rep = x._rep;

    _packMagicByte(out);
    _packName(out, rep->getName());
    _packType(out, rep->getType());
    _packName(out, rep->getClassOrigin());
    Packer::packBoolean(out, rep->getPropagated());
    PackQualifiers<CIMMethodRep>::func(out, rep);
    _packParameters(out, rep);
}

void BinaryStreamer::_unpackMethod(
    const Buffer& in, Uint32& pos, CIMMethod& x)
{
    _checkMagicByte(in, pos);

    CIMName name;
    _unpackName(in, pos, name);

    CIMType type;
    _unpackType(in, pos, type);

    CIMName classOrigin;
    _unpackName(in, pos, classOrigin);

    Boolean propagated;
    Packer::unpackBoolean(in, pos, propagated);

    CIMMethod cimMethod(name, type, classOrigin, propagated);
    UnpackQualifiers<CIMMethod>::func(in, pos, cimMethod);
    _unpackParameters(in, pos, cimMethod);

    x = cimMethod;
}

void BinaryStreamer::_packObjectPath(Buffer& out, const CIMObjectPath& x)
{
    Packer::packString(out, x.toString());
}

void BinaryStreamer::_unpackObjectPath(
    const Buffer& in, Uint32& pos, CIMObjectPath& x)
{
    String tmp;
    Packer::unpackString(in, pos, tmp);
    x = CIMObjectPath(tmp);
}

void BinaryStreamer::_packProperties(Buffer& out, CIMObjectRep* rep)
{
    Uint32 n = rep->getPropertyCount();
    Packer::packSize(out, n);

    for (Uint32 i = 0; i < n; i++)
        BinaryStreamer::_packProperty(out, rep->getProperty(i));
}

void BinaryStreamer::_packMethods(Buffer& out, CIMClassRep* rep)
{
    Uint32 n = rep->getMethodCount();
    Packer::packSize(out, n);

    for (Uint32 i = 0; i < n; i++)
        BinaryStreamer::_packMethod(out, rep->getMethod(i));
}

void BinaryStreamer::_packScope(Buffer& out, const CIMScope& x)
{
    Packer::packUint32(out, x.cimScope);
}

void BinaryStreamer::_unpackScope(
    const Buffer& in, Uint32& pos, CIMScope& x)
{
    Packer::unpackUint32(in, pos, x.cimScope);
}

void BinaryStreamer::_packFlavor(Buffer& out, const CIMFlavor& x)
{
    Packer::packUint32(out, x.cimFlavor);
}

void BinaryStreamer::_unpackFlavor(
    const Buffer& in, Uint32& pos, CIMFlavor& x)
{
    Packer::unpackUint32(in, pos, x.cimFlavor);
}

void BinaryStreamer::_packType(Buffer& out, const CIMType& x)
{
    Packer::packUint8(out, Uint8(x));
}

void BinaryStreamer::_unpackType(
    const Buffer& in, Uint32& pos, CIMType& x)
{
    Uint8 tmp;
    Packer::unpackUint8(in, pos, tmp);
    x = CIMType(tmp);
}

void BinaryStreamer::encode(
    Buffer& out,
    const CIMClass& x)
{
    CIMClassRep* rep = x._rep;
    _packMagicByte(out);
    _packHeader(out, BINARY_CLASS);
    _packName(out, x.getClassName());
    _packName(out, x.getSuperClassName());
    PackQualifiers<CIMClassRep>::func(out, rep);
    _packProperties(out, rep);
    _packMethods(out, rep);
    Packer::packBoolean(out, rep->_resolved);
}

void BinaryStreamer::decode(
    const Buffer& in,
    unsigned int pos,
    CIMClass& x)
{
    _checkMagicByte(in, pos);
    _checkHeader(in, pos, BINARY_CLASS);

    CIMName className;
    _unpackName(in, pos, className);

    CIMName superClassName;
    _unpackName(in, pos, superClassName);

    CIMClass cimClass(className, superClassName);

    UnpackQualifiers<CIMClass>::func(in, pos, cimClass);
    UnpackProperties<CIMClass>::func(in, pos, cimClass);
    UnpackMethods<CIMClass>::func(in, pos, cimClass);

    Boolean resolved;
    Packer::unpackBoolean(in, pos, resolved);
    cimClass._rep->_resolved = resolved;
    x = cimClass;
}

void BinaryStreamer::encode(
    Buffer& out,
    const CIMInstance& x)
{
    CIMInstanceRep* rep = x._rep;
    _packMagicByte(out);
    _packHeader(out, BINARY_INSTANCE);
    _packObjectPath(out, x.getPath());
    PackQualifiers<CIMInstanceRep>::func(out, rep);
    _packProperties(out, rep);
    Packer::packBoolean(out, rep->_resolved);
}

void BinaryStreamer::decode(
    const Buffer& in,
    unsigned int pos,
    CIMInstance& x)
{
    _checkMagicByte(in, pos);
    _checkHeader(in, pos, BINARY_INSTANCE);

    CIMObjectPath objectPath;
    _unpackObjectPath(in, pos, objectPath);
    CIMInstance cimInstance(objectPath.getClassName());
    cimInstance.setPath(objectPath);

    UnpackQualifiers<CIMInstance>::func(in, pos, cimInstance);
    UnpackProperties<CIMInstance>::func(in, pos, cimInstance);

    Boolean resolved;
    Packer::unpackBoolean(in, pos, resolved);
    cimInstance._rep->_resolved = resolved;
    x = cimInstance;
}

void BinaryStreamer::encode(
    Buffer& out,
    const CIMQualifierDecl& x)
{
    _packMagicByte(out);
    _packHeader(out, BINARY_QUALIFIER_DECL);
    _packName(out , x.getName());
    _packValue(out , x.getValue());
    _packScope(out , x.getScope());
    _packFlavor(out , x.getFlavor());
    Packer::packSize(out, x.getArraySize());
}

void BinaryStreamer::decode(
    const Buffer& in,
    unsigned int pos,
    CIMQualifierDecl& x)
{
    _checkMagicByte(in, pos);
    _checkHeader(in, pos, BINARY_QUALIFIER_DECL);

    CIMName qualifierName;
    _unpackName(in, pos, qualifierName);

    CIMValue value;
    _unpackValue(in, pos, value);

    CIMScope scope;
    _unpackScope(in, pos, scope);

    CIMFlavor flavor;
    BinaryStreamer::_unpackFlavor(in, pos, flavor);

    Uint32 arraySize;
    Packer::unpackSize(in, pos, arraySize);

    x = CIMQualifierDecl(qualifierName, value, scope, flavor, arraySize);
}

PEGASUS_NAMESPACE_END