cimvalue.cpp

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

    CIMValueType<Sint64>::set(_rep, x);
}

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

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

CIMValue::CIMValue(const Char16& x)
{
    _rep = new CIMValueRep;
    CIMValueType<Char16>::set(_rep, x);
}

CIMValue::CIMValue(const String& x)
{
    _rep = new CIMValueRep;
    CIMValueType<String>::set(_rep, x);
}

CIMValue::CIMValue(const CIMDateTime& x)
{
    _rep = new CIMValueRep;
    CIMValueType<CIMDateTime>::set(_rep, x);
}

CIMValue::CIMValue(const CIMObjectPath& x)
{
    _rep = new CIMValueRep;
    CIMValueType<CIMObjectPath>::set(_rep, x);
}

CIMValue::CIMValue(const CIMObject& x)
{
    if (x.isUninitialized())
    {
        // Bug 3373, throw exception if uninitialized object is passed to set().
        throw UninitializedObjectException();
    }

    _rep = new CIMValueRep;
    CIMValueType<CIMObject>::set(_rep, x.clone());
}
#ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT
CIMValue::CIMValue(const CIMInstance& x)
{
    if (x.isUninitialized())
    {
        // Bug 3373, throw exception if uninitialized object is passed to set().
        throw UninitializedObjectException();
    }

    _rep = new CIMValueRep;
    CIMValueType<CIMInstance>::set(_rep, x.clone());
}
#endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT
CIMValue::CIMValue(const Array<Boolean>& x)
{
    _rep = new CIMValueRep;
    CIMValueType<Boolean>::setArray(_rep, x);
}

CIMValue::CIMValue(const Array<Uint8>& x)
{
    _rep = new CIMValueRep;
    CIMValueType<Uint8>::setArray(_rep, x);
}

CIMValue::CIMValue(const Array<Sint8>& x)
{
    _rep = new CIMValueRep;
    CIMValueType<Sint8>::setArray(_rep, x);
}

CIMValue::CIMValue(const Array<Uint16>& x)
{
    _rep = new CIMValueRep;
    CIMValueType<Uint16>::setArray(_rep, x);
}

CIMValue::CIMValue(const Array<Sint16>& x)
{
    _rep = new CIMValueRep;
    CIMValueType<Sint16>::setArray(_rep, x);
}

CIMValue::CIMValue(const Array<Uint32>& x)
{
    _rep = new CIMValueRep;
    CIMValueType<Uint32>::setArray(_rep, x);
}

CIMValue::CIMValue(const Array<Sint32>& x)
{
    _rep = new CIMValueRep;
    CIMValueType<Sint32>::setArray(_rep, x);
}

CIMValue::CIMValue(const Array<Uint64>& x)
{
    _rep = new CIMValueRep;
    CIMValueType<Uint64>::setArray(_rep, x);
}

CIMValue::CIMValue(const Array<Sint64>& x)
{
    _rep = new CIMValueRep;
    CIMValueType<Sint64>::setArray(_rep, x);
}

CIMValue::CIMValue(const Array<Real32>& x)
{
    _rep = new CIMValueRep;
    CIMValueType<Real32>::setArray(_rep, x);
}

CIMValue::CIMValue(const Array<Real64>& x)
{
    _rep = new CIMValueRep;
    CIMValueType<Real64>::setArray(_rep, x);
}

CIMValue::CIMValue(const Array<Char16>& x)
{
    _rep = new CIMValueRep;
    CIMValueType<Char16>::setArray(_rep, x);
}

CIMValue::CIMValue(const Array<String>& x)
{
    _rep = new CIMValueRep;
    CIMValueType<String>::setArray(_rep, x);
}

CIMValue::CIMValue(const Array<CIMDateTime>& x)
{
    _rep = new CIMValueRep;
    CIMValueType<CIMDateTime>::setArray(_rep, x);
}

CIMValue::CIMValue(const Array<CIMObjectPath>& x)
{
    _rep = new CIMValueRep;
    CIMValueType<CIMObjectPath>::setArray(_rep, x);
}

CIMValue::CIMValue(const Array<CIMObject>& x)
{
    Array<CIMObject> tmp;

    for (Uint32 i = 0, n = x.size(); i < n; i++)
    {
        if (x[i].isUninitialized())
        {
            // Bug 3373, throw exception on uninitialized object.
            _rep = &CIMValueRep::_emptyRep;
            throw UninitializedObjectException();
        }

        tmp.append(x[i].clone());
    }

    _rep = new CIMValueRep;
    CIMValueType<CIMObject>::setArray(_rep, tmp);
}

#ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT
CIMValue::CIMValue(const Array<CIMInstance>& x)
{
    Array<CIMInstance> tmp;

    for (Uint32 i = 0, n = x.size(); i < n; i++)
    {
        if (x[i].isUninitialized())
        {
          // Bug 3373, throw exception on uninitialized object.
          _rep = &CIMValueRep::_emptyRep;
          throw UninitializedObjectException();
        }

        tmp.append(x[i].clone());
    }
    _rep = new CIMValueRep;
    CIMValueType<CIMInstance>::setArray(_rep, tmp);
}
#endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT

void CIMValue::clear()
{
    CIMValueRep::unref(_rep);
    _rep = &CIMValueRep::_emptyRep;
}

CIMValue& CIMValue::operator=(const CIMValue& x)
{
    if (_rep != x._rep)
    {
        CIMValueRep::unref(_rep);
        CIMValueRep::ref(_rep = x._rep);
    }

    return *this;
}

void CIMValue::assign(const CIMValue& x)
{
    if (_rep != x._rep)
    {
        CIMValueRep::unref(_rep);
        CIMValueRep::ref(_rep = x._rep);
    }
}

Boolean CIMValue::typeCompatible(const CIMValue& x) const
{
    return (_rep->type == x._rep->type && _rep->isArray == x._rep->isArray);
}

Uint32 CIMValue::getArraySize() const
{
    if (!_rep->isArray)
        return 0;

    switch (_rep->type)
    {
        case CIMTYPE_BOOLEAN:
            return CIMValueType<Boolean>::arraySize(_rep);

        case CIMTYPE_UINT8:
            return CIMValueType<Uint8>::arraySize(_rep);

        case CIMTYPE_SINT8:
            return CIMValueType<Sint8>::arraySize(_rep);

        case CIMTYPE_UINT16:
            return CIMValueType<Uint16>::arraySize(_rep);

        case CIMTYPE_SINT16:
            return CIMValueType<Sint16>::arraySize(_rep);

        case CIMTYPE_UINT32:
            return CIMValueType<Uint32>::arraySize(_rep);

        case CIMTYPE_SINT32:
            return CIMValueType<Sint32>::arraySize(_rep);

        case CIMTYPE_UINT64:
            return CIMValueType<Uint64>::arraySize(_rep);

        case CIMTYPE_SINT64:
            return CIMValueType<Sint64>::arraySize(_rep);

        case CIMTYPE_REAL32:
            return CIMValueType<Real32>::arraySize(_rep);

        case CIMTYPE_REAL64:
            return CIMValueType<Real64>::arraySize(_rep);

        case CIMTYPE_CHAR16:
            return CIMValueType<Char16>::arraySize(_rep);

        case CIMTYPE_STRING:
            return CIMValueType<String>::arraySize(_rep);

        case CIMTYPE_DATETIME:
            return CIMValueType<CIMDateTime>::arraySize(_rep);

        case CIMTYPE_REFERENCE:
            return CIMValueType<CIMObjectPath>::arraySize(_rep);

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

    return 0;
}

void CIMValue::setNullValue(CIMType type, Boolean isArray, Uint32 arraySize)
{
    //
    // Release any memory:
    //

    _release(_rep);

    //
    // Set the null value:
    //

    switch (type)
    {
        case CIMTYPE_BOOLEAN:
            CIMValueType<Boolean>::setNull(_rep, type, isArray, arraySize);
            break;

        case CIMTYPE_UINT8:
            CIMValueType<Uint8>::setNull(_rep, type, isArray, arraySize);
            break;

        case CIMTYPE_SINT8:
            CIMValueType<Sint8>::setNull(_rep, type, isArray, arraySize);
            break;

        case CIMTYPE_UINT16:
            CIMValueType<Uint16>::setNull(_rep, type, isArray, arraySize);
            break;

        case CIMTYPE_SINT16:
            CIMValueType<Sint16>::setNull(_rep, type, isArray, arraySize);
            break;

        case CIMTYPE_UINT32:
            CIMValueType<Uint32>::setNull(_rep, type, isArray, arraySize);
            break;

        case CIMTYPE_SINT32:
            CIMValueType<Sint32>::setNull(_rep, type, isArray, arraySize);
            break;

        case CIMTYPE_UINT64:
            CIMValueType<Uint64>::setNull(_rep, type, isArray, arraySize);
            break;

        case CIMTYPE_SINT64:
            CIMValueType<Sint64>::setNull(_rep, type, isArray, arraySize);
            break;

        case CIMTYPE_REAL32:
            CIMValueType<Real32>::setNull(_rep, type, isArray, arraySize);
            break;

        case CIMTYPE_REAL64:
            CIMValueType<Real64>::setNull(_rep, type, isArray, arraySize);
            break;

        case CIMTYPE_CHAR16:
            CIMValueType<Char16>::setNull(_rep, type, isArray, arraySize);
            break;

        case CIMTYPE_STRING:
            CIMValueType<String>::setNull(_rep, type, isArray, arraySize);
            break;

        case CIMTYPE_DATETIME:
            CIMValueType<CIMDateTime>::setNull(_rep, type, isArray, arraySize);
            break;

        case CIMTYPE_REFERENCE:
            CIMValueType<CIMObjectPath>::setNull(_rep, type, isArray,arraySize);
            break;

        case CIMTYPE_OBJECT:
            CIMValueType<CIMObject>::setNull(_rep, type, isArray, arraySize);
            break;
#ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT
        case CIMTYPE_INSTANCE:
            CIMValueType<CIMInstance>::setNull(_rep, type, isArray, arraySize);
            break;
#endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT
        default:
            PEGASUS_ASSERT(0);
    }
}

void CIMValue::set(Boolean x)
{
    _release(_rep);
    CIMValueType<Boolean>::set(_rep, x);
}

void CIMValue::set(Uint8 x)
{
    _release(_rep);
    CIMValueType<Uint8>::set(_rep, x);
}

void CIMValue::set(Sint8 x)
{
    _release(_rep);
    CIMValueType<Sint8>::set(_rep, x);
}

void CIMValue::set(Uint16 x)
{
    _release(_rep);
    CIMValueType<Uint16>::set(_rep, x);
}

void CIMValue::set(Sint16 x)
{
    _release(_rep);
    CIMValueType<Sint16>::set(_rep, x);
}

void CIMValue::set(Uint32 x)
{
    _release(_rep);
    CIMValueType<Uint32>::set(_rep, x);
}

void CIMValue::set(Sint32 x)
{
    _release(_rep);
    CIMValueType<Sint32>::set(_rep, x);
}

void CIMValue::set(Uint64 x)
{
    _release(_rep);
    CIMValueType<Uint64>::set(_rep, x);
}

void CIMValue::set(Sint64 x)
{
    _release(_rep);
    CIMValueType<Sint64>::set(_rep, x);
}

void CIMValue::set(Real32 x)
{
    _release(_rep);
    CIMValueType<Real32>::set(_rep, x);
}

void CIMValue::set(Real64 x)
{
    _release(_rep);
    CIMValueType<Real64>::set(_rep, x);
}

void CIMValue::set(const Char16& x)
{
    _release(_rep);
    CIMValueType<Char16>::set(_rep, x);
}

void CIMValue::set(const String& x)
{
    _release(_rep);
    CIMValueType<String>::set(_rep, x);
}

void CIMValue::set(const CIMDateTime& x)
{
    _release(_rep);
    CIMValueType<CIMDateTime>::set(_rep, x);