cimvalue.cpp

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

    if (_rep->type != CIMTYPE_OBJECT || !_rep->isArray)
        throw TypeMismatchException();

    if (!_rep->isNull)
    {
        x.clear();

        // We have to clone our own unique copy since we are about to
        // return an object to the caller that he can modify; thereby,
        // changing the one we refer to as well.
        for (Uint32 i = 0, n = CIMValueType<CIMObject>::arraySize(_rep);
             i < n; i++)
        {
            x.append(CIMValueType<CIMObject>::aref(_rep)[i].clone());
        }
    }
}

#ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT
void CIMValue::get(Array<CIMInstance>& x) const
{
    if (_rep->type != CIMTYPE_INSTANCE || !_rep->isArray)
        throw TypeMismatchException();

    if (!_rep->isNull)
    {
        x.clear();

        // We have to clone our own unique copy since we are about to
        // return an object to the caller that he can modify; thereby,
        // changing the one we refer to as well.
        for (Uint32 i = 0, n = CIMValueType<CIMInstance>::arraySize(_rep);
             i < n; i++)
        {
            x.append(CIMValueType<CIMInstance>::aref(_rep)[i].clone());
        }
    }
}
#endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT

Boolean CIMValue::equal(const CIMValue& x) const
{
    if (!typeCompatible(x))
        return false;

    if (_rep->isNull != x._rep->isNull)
        return false;

    if (_rep->isNull)
        return true;

    if (_rep->isArray)
    {
        switch (_rep->type)
        {
            case CIMTYPE_BOOLEAN:
                return CIMValueType<Boolean>::equalArray(_rep, x._rep);

            case CIMTYPE_UINT8:
                return CIMValueType<Uint8>::equalArray(_rep, x._rep);

            case CIMTYPE_SINT8:
                return CIMValueType<Sint8>::equalArray(_rep, x._rep);

            case CIMTYPE_UINT16:
                return CIMValueType<Uint16>::equalArray(_rep, x._rep);

            case CIMTYPE_SINT16:
                return CIMValueType<Sint16>::equalArray(_rep, x._rep);

            case CIMTYPE_UINT32:
                return CIMValueType<Uint32>::equalArray(_rep, x._rep);

            case CIMTYPE_SINT32:
                return CIMValueType<Sint32>::equalArray(_rep, x._rep);

            case CIMTYPE_UINT64:
                return CIMValueType<Uint64>::equalArray(_rep, x._rep);

            case CIMTYPE_SINT64:
                return CIMValueType<Sint64>::equalArray(_rep, x._rep);

            case CIMTYPE_REAL32:
                return CIMValueType<Real32>::equalArray(_rep, x._rep);

            case CIMTYPE_REAL64:
                return CIMValueType<Real64>::equalArray(_rep, x._rep);

            case CIMTYPE_CHAR16:
                return CIMValueType<Char16>::equalArray(_rep, x._rep);

            case CIMTYPE_STRING:
                return CIMValueType<String>::equalArray(_rep, x._rep);

            case CIMTYPE_DATETIME:
                return CIMValueType<CIMDateTime>::equalArray(_rep, x._rep);

            case CIMTYPE_REFERENCE:
                return CIMValueType<CIMObjectPath>::equalArray(_rep, x._rep);

            case CIMTYPE_OBJECT:
                return CIMValueType<CIMObject>::equalArray(_rep, x._rep);
#ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT
            case CIMTYPE_INSTANCE:
                return CIMValueType<CIMInstance>::equalArray(_rep, x._rep);
#endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT
            default:
                PEGASUS_ASSERT(0);
        }
    }
    else
    {
        switch (_rep->type)
        {
            case CIMTYPE_BOOLEAN:
                return CIMValueType<Boolean>::equal(_rep, x._rep);

            case CIMTYPE_UINT8:
                return CIMValueType<Uint8>::equal(_rep, x._rep);

            case CIMTYPE_SINT8:
                return CIMValueType<Sint8>::equal(_rep, x._rep);

            case CIMTYPE_UINT16:
                return CIMValueType<Uint16>::equal(_rep, x._rep);

            case CIMTYPE_SINT16:
                return CIMValueType<Sint16>::equal(_rep, x._rep);

            case CIMTYPE_UINT32:
                return CIMValueType<Uint32>::equal(_rep, x._rep);

            case CIMTYPE_SINT32:
                return CIMValueType<Sint32>::equal(_rep, x._rep);

            case CIMTYPE_UINT64:
                return CIMValueType<Uint64>::equal(_rep, x._rep);

            case CIMTYPE_SINT64:
                return CIMValueType<Sint64>::equal(_rep, x._rep);

            case CIMTYPE_REAL32:
                return CIMValueType<Real32>::equal(_rep, x._rep);

            case CIMTYPE_REAL64:
                return CIMValueType<Real64>::equal(_rep, x._rep);

            case CIMTYPE_CHAR16:
                return CIMValueType<Char16>::equal(_rep, x._rep);

            case CIMTYPE_STRING:
                return CIMValueType<String>::equal(_rep, x._rep);

            case CIMTYPE_DATETIME:
                return CIMValueType<CIMDateTime>::equal(_rep, x._rep);

            case CIMTYPE_REFERENCE:
                return CIMValueType<CIMObjectPath>::equal(_rep, x._rep);

            case CIMTYPE_OBJECT:
                return CIMValueType<CIMObject>::ref(_rep).identical(
                    CIMValueType<CIMObject>::ref(x._rep));
#ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT
            case CIMTYPE_INSTANCE:
                return CIMValueType<CIMInstance>::ref(_rep).identical(
                    CIMValueType<CIMInstance>::ref(x._rep));
#endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT
            default:
                PEGASUS_ASSERT(0);
        }
    }

    return false;
}

String CIMValue::toString() const
{
    Buffer out;

    // ATTN: Not sure what we should do with getstring for Null CIMValues
    // Choice return empty string or exception out.

    if (_rep->isNull)
        return String();

    if (_rep->isArray)
    {
        switch (_rep->type)
        {
            case CIMTYPE_BOOLEAN:
            {
                const Array<Boolean>& a = CIMValueType<Boolean>::aref(_rep);
                Uint32 size = a.size();

                for (Uint32 i = 0; i < size; i++)
                {
                    _toString(out, a[i]);
                    out.append(' ');
                }
                break;
            }

            case CIMTYPE_UINT8:
            {
                const Array<Uint8>& a = CIMValueType<Uint8>::aref(_rep);
                _toString(out, a.getData(), a.size());
                break;
            }

            case CIMTYPE_SINT8:
            {
                const Array<Sint8>& a = CIMValueType<Sint8>::aref(_rep);
                _toString(out, a.getData(), a.size());
                break;
            }

            case CIMTYPE_UINT16:
            {
                const Array<Uint16>& a = CIMValueType<Uint16>::aref(_rep);
                _toString(out, a.getData(), a.size());
                break;
            }

            case CIMTYPE_SINT16:
            {
                const Array<Sint16>& a = CIMValueType<Sint16>::aref(_rep);
                _toString(out, a.getData(), a.size());
                break;
            }

            case CIMTYPE_UINT32:
            {
                const Array<Uint32>& a = CIMValueType<Uint32>::aref(_rep);
                _toString(out, a.getData(), a.size());
                break;
            }

            case CIMTYPE_SINT32:
            {
                const Array<Sint32>& a = CIMValueType<Sint32>::aref(_rep);
                _toString(out, a.getData(), a.size());
                break;
            }

            case CIMTYPE_UINT64:
            {
                const Array<Uint64>& a = CIMValueType<Uint64>::aref(_rep);
                _toString(out, a.getData(), a.size());
                break;
            }

            case CIMTYPE_SINT64:
            {
                const Array<Sint64>& a = CIMValueType<Sint64>::aref(_rep);
                _toString(out, a.getData(), a.size());
                break;
            }

            case CIMTYPE_REAL32:
            {
                const Array<Real32>& a = CIMValueType<Real32>::aref(_rep);
                _toString(out, a.getData(), a.size());
                break;
            }

            case CIMTYPE_REAL64:
            {
                const Array<Real64>& a = CIMValueType<Real64>::aref(_rep);
                _toString(out, a.getData(), a.size());
                break;
            }

            case CIMTYPE_CHAR16:
            {
                const Array<Char16>& a = CIMValueType<Char16>::aref(_rep);
                _toString(out, a.getData(), a.size());
                break;
            }

            case CIMTYPE_STRING:
            {
                const Array<String>& a = CIMValueType<String>::aref(_rep);
                _toString(out, a.getData(), a.size());
                break;
            }

            case CIMTYPE_DATETIME:
            {
                const Array<CIMDateTime>& a =
                    CIMValueType<CIMDateTime>::aref(_rep);
                _toString(out, a.getData(), a.size());
                break;
            }

            case CIMTYPE_REFERENCE:
            {
                const Array<CIMObjectPath>& a =
                    CIMValueType<CIMObjectPath>::aref(_rep);
                _toString(out, a.getData(), a.size());
                break;
            }

            case CIMTYPE_OBJECT:
            {
                const Array<CIMObject>& a = CIMValueType<CIMObject>::aref(_rep);
                _toString(out, a.getData(), a.size());
                break;
            }
#ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT
            case CIMTYPE_INSTANCE:
            {
                const Array<CIMInstance>& a =
                    CIMValueType<CIMInstance>::aref(_rep);
                _toString(out, a.getData(), a.size());
                break;
            }
#endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT
            default:
                PEGASUS_ASSERT(0);
        }
    }
    else
    {
        switch (_rep->type)
        {
            case CIMTYPE_BOOLEAN:
                _toString(out, CIMValueType<Boolean>::ref(_rep));
                break;

            case CIMTYPE_UINT8:
                _toString(out, CIMValueType<Uint8>::ref(_rep));
                break;

            case CIMTYPE_SINT8:
                _toString(out, CIMValueType<Sint8>::ref(_rep));
                break;

            case CIMTYPE_UINT16:
                _toString(out, CIMValueType<Uint16>::ref(_rep));
                break;

            case CIMTYPE_SINT16:
                _toString(out, CIMValueType<Sint16>::ref(_rep));
                break;

            case CIMTYPE_UINT32:
                _toString(out, CIMValueType<Uint32>::ref(_rep));
                break;

            case CIMTYPE_SINT32:
                _toString(out, CIMValueType<Sint32>::ref(_rep));
                break;

            case CIMTYPE_UINT64:
                _toString(out, CIMValueType<Uint64>::ref(_rep));
                break;

            case CIMTYPE_SINT64:
                _toString(out, CIMValueType<Sint64>::ref(_rep));
                break;

            case CIMTYPE_REAL32:
                _toString(out, CIMValueType<Real32>::ref(_rep));
                break;

            case CIMTYPE_REAL64:
                _toString(out, CIMValueType<Real64>::ref(_rep));
                break;

            case CIMTYPE_CHAR16:
                _toString(out, CIMValueType<Char16>::ref(_rep));
                break;

            case CIMTYPE_STRING:
                _toString(out, CIMValueType<String>::ref(_rep));
                break;

            case CIMTYPE_DATETIME:
                _toString(out, CIMValueType<CIMDateTime>::ref(_rep));
                break;

            case CIMTYPE_REFERENCE:
                _toString(out, CIMValueType<CIMObjectPath>::ref(_rep));
                break;

            case CIMTYPE_OBJECT:
                _toString(out, CIMValueType<CIMObject>::ref(_rep));
                break;
#ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT
            case CIMTYPE_INSTANCE:
                _toString(out, CIMValueType<CIMInstance>::ref(_rep));
                break;
#endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT
            default:
                PEGASUS_ASSERT(0);
        }
    }

    out.append('\0');

    return out.getData();
}

#ifdef PEGASUS_USE_DEPRECATED_INTERFACES

CIMValue::CIMValue(char x)
{
    _rep = new CIMValueRep;
    CIMValueType<Sint8>::set(_rep, (Sint8)x);
}

CIMValue::CIMValue(const Array<char>& x)
{
    _rep = new CIMValueRep;
    Array<Sint8> tmp((Sint8*)x.getData(), x.size());
    CIMValueType<Sint8>::setArray(_rep, tmp);
}

void CIMValue::set(char x)
{
    set(static_cast<Sint8>(x));
}

void CIMValue::set(const Array<char>& x)
{
    set(*reinterpret_cast<const Array<Sint8>*>(&x));
}

void CIMValue::get(char& x) const
{
    get(*reinterpret_cast<Sint8*>(&x));
}

void CIMValue::get(Array<char>& x) const
{
    get(*reinterpret_cast<Array<Sint8>*>(&x));
}

#endif /* PEGASUS_USE_DEPRECATED_INTERFACES */

void CIMValue::_get(const String*& data, Uint32& size) const
{
    const Array<String>& a = CIMValueType<String>::aref(_rep);
    data = a.getData();
    size = a.size();
}

Boolean operator==(const CIMValue& x, const CIMValue& y)
{
    return x.equal(y);
}

Boolean operator!=(const CIMValue& x, const CIMValue& y)
{
    return !x.equal(y);
}

PEGASUS_NAMESPACE_END