OW_CppSimpleAssociatorProviderIFC.cpp

Go to the documentation of this file.

/*******************************************************************************
* Copyright (C) 2004 Novell, Inc All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
*  - Redistributions of source code must retain the above copyright notice,
*    this list of conditions and the following disclaimer.
*
*  - Redistributions in binary form must reproduce the above copyright notice,
*    this list of conditions and the following disclaimer in the documentation
*    and/or other materials provided with the distribution.
*
*  - Neither the name of Novell nor the names of its
*    contributors may be used to endorse or promote products derived from this
*    software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS IS''
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL Novell, Inc OR THE CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*******************************************************************************/

#include "OW_config.h"
#include "OW_CppSimpleAssociatorProviderIFC.hpp"
#include "OW_CIMInstance.hpp"
#include "OW_CIMClass.hpp"
#include "OW_CIMObjectPath.hpp"
#include "OW_CIMProperty.hpp"
#include "OW_CIMValue.hpp"
#include "OW_CIMNameSpace.hpp"
#include "OW_ResultHandlerIFC.hpp"
#include "OW_CIMOMHandleIFC.hpp"


namespace OW_NAMESPACE
{
namespace
{
    class AssocHelperResultHandlerIFC : public CIMInstanceResultHandlerIFC
    {
    public:
        AssocHelperResultHandlerIFC(const CIMObjectPath& objectName,
            const String& resultClass, const String& role,
            const String& resultRole)
            : _objectName(objectName)
            , _resultClass(resultClass)
            , _role(role)
            , _resultRole(resultRole) {}
        void doHandle(const CIMInstance& inst)
        {
            if (_resultRole.length() > 0)
            {
                CIMProperty prop = inst.getProperty(_resultRole);

                if (prop)
                {
                    CIMObjectPath cop;
                    prop.getValue().get(cop);
                    assocAuxHandler(cop);
                }
            }
            else
            {
                CIMPropertyArray cpa = inst.getProperties();
                for (CIMPropertyArray::const_iterator iter = cpa.begin();
                      iter < cpa.end(); ++iter)
                {
                    CIMDataType dt = iter->getDataType();
                    if (!dt.isReferenceType())
                    {
                        continue;
                    }
                    String propName = iter->getName();
                    if (_role == propName)
                    {
                        continue;
                    }
                    CIMObjectPath cop;
                    iter->getValue().get(cop);
                    if (cop != _objectName)
                    {
                        assocAuxHandler(cop);
                    }
                }
            }
        }
    protected:
        virtual void assocAuxHandler(const CIMObjectPath& cop) = 0;
    private:
        CIMObjectPath _objectName;
        String _resultClass;
        String _role;
        String _resultRole;
    };


    class _RHAssociators : public AssocHelperResultHandlerIFC
    {
    public:
        _RHAssociators(CIMInstanceResultHandlerIFC& result,
            const CIMObjectPath& objectName,
            const String& resultClass,
            const String& role,
            const String& resultRole,
            const CIMOMHandleIFCRef& lch,
            WBEMFlags:: EIncludeQualifiersFlag includeQualifiers,
            WBEMFlags:: EIncludeClassOriginFlag includeClassOrigin,
            const StringArray *propertyList)
        : AssocHelperResultHandlerIFC(objectName,resultClass ,role ,resultRole)
        , _realHandler(result)
        , _lch(lch)
        , _includeQualifiers(includeQualifiers)
        , _includeClassOrigin(includeClassOrigin)
        , _propertyList(propertyList)
        {}
    protected:
        virtual void assocAuxHandler(const CIMObjectPath &cop)
        {
            CIMInstance inst = _lch->getInstance(cop.getFullNameSpace().getNameSpace(),
                              cop, WBEMFlags::E_NOT_LOCAL_ONLY,
                              _includeQualifiers, _includeClassOrigin,
                              _propertyList);
            _realHandler.handle(inst);
        }
    private:
        CIMInstanceResultHandlerIFC& _realHandler;
        const CIMOMHandleIFCRef& _lch;
        WBEMFlags::EIncludeQualifiersFlag _includeQualifiers;
        WBEMFlags::EIncludeClassOriginFlag _includeClassOrigin;
        const StringArray* _propertyList;
    };

    class _RHAssociatorNames : public AssocHelperResultHandlerIFC
    {
    public:
        _RHAssociatorNames(CIMObjectPathResultHandlerIFC& result,
            const CIMObjectPath& objectName,
            const String& resultClass,
            const String& role,
            const String& resultRole)
        : AssocHelperResultHandlerIFC(objectName,resultClass ,role ,resultRole)
        , _realHandler(result) { }
    protected:
        virtual void assocAuxHandler(const CIMObjectPath &cop)
        {
            _realHandler.handle(cop);
        }
    private:
        CIMObjectPathResultHandlerIFC& _realHandler;
    };

    class _RHReferences : public CIMInstanceResultHandlerIFC
    {
    public:
        _RHReferences(CIMInstanceResultHandlerIFC& realHandler,
            WBEMFlags:: EIncludeQualifiersFlag includeQualifiers,
            WBEMFlags:: EIncludeClassOriginFlag includeClassOrigin,
            const StringArray *propertyList)
            : _realHandler(realHandler)
            , _includeQualifiers(includeQualifiers)
            , _includeClassOrigin(includeClassOrigin)
            , _propertyList(propertyList)
        {
        }

        void doHandle(const CIMInstance& inst)
        {
            CIMInstance rval = inst.clone(WBEMFlags::E_NOT_LOCAL_ONLY,
                                                  _includeQualifiers,
                                                  _includeClassOrigin,
                                                  _propertyList);
            _realHandler.handle(rval);
        }
    private:
        CIMInstanceResultHandlerIFC& _realHandler;
        WBEMFlags::EIncludeQualifiersFlag _includeQualifiers;
        WBEMFlags::EIncludeClassOriginFlag _includeClassOrigin;
        const StringArray* _propertyList;
    };

    class _RHReferenceNames : public CIMInstanceResultHandlerIFC
    {
    public:
        _RHReferenceNames(CIMObjectPathResultHandlerIFC& realHandler, const String& ns)
            : _realHandler(realHandler)
            , _ns(ns) {}
        void doHandle(const CIMInstance& inst)
        {
            CIMObjectPath cop(_ns, inst);
            _realHandler.handle(cop);
        }
    private:
        CIMObjectPathResultHandlerIFC& _realHandler;
        String _ns;
    };

} // end anonymous namespace

void
    CppSimpleAssociatorProviderIFC::associators(const ProviderEnvironmentIFCRef &env,
                                                CIMInstanceResultHandlerIFC &result,
                                                const String &ns,
                                                const CIMObjectPath &objectName,
                                                const String &assocClass,
                                                const String &resultClass,
                                                const String &role,
                                                const String &resultRole,
                                                WBEMFlags:: EIncludeQualifiersFlag includeQualifiers,
                                                WBEMFlags:: EIncludeClassOriginFlag includeClassOrigin,
                                                const StringArray *propertyList)
{

    CIMOMHandleIFCRef lch = env->getCIMOMHandle();
    CIMClass theAssocClass = lch->getClass(ns, assocClass);
    _RHAssociators rh(result, objectName, resultClass, role, resultRole,
           lch, includeQualifiers, includeClassOrigin, propertyList);

    doReferences(env, rh, ns, objectName, theAssocClass, resultClass,
                 role, resultRole);
}
void
    CppSimpleAssociatorProviderIFC::associatorNames(const ProviderEnvironmentIFCRef &env,
                                                    CIMObjectPathResultHandlerIFC &result,
                                                    const String &ns,
                                                    const CIMObjectPath &objectName,
                                                    const String &assocClass,
                                                    const String &resultClass,
                                                    const String &role,
                                                    const String &resultRole)
{


    _RHAssociatorNames rh(result, objectName, resultClass, role, resultRole);

    CIMOMHandleIFCRef lch = env->getCIMOMHandle();
    CIMClass theAssocClass = lch->getClass(ns, assocClass);

    doReferences(env, rh, ns, objectName, theAssocClass, resultClass,
                 role, resultRole);
}

void
    CppSimpleAssociatorProviderIFC::references(const ProviderEnvironmentIFCRef
                                               &env, CIMInstanceResultHandlerIFC &result,
                                               const String &ns,
                                               const CIMObjectPath &objectName,
                                               const String &resultClass,
                                               const String &role,
                                               WBEMFlags:: EIncludeQualifiersFlag includeQualifiers,
                                               WBEMFlags:: EIncludeClassOriginFlag includeClassOrigin,
                                               const StringArray *propertyList)
{

    CIMOMHandleIFCRef lch = env->getCIMOMHandle();
    CIMClass theAssocClass = lch->getClass(ns, resultClass,
                                           WBEMFlags::E_NOT_LOCAL_ONLY,
                                           includeQualifiers,
                                           includeClassOrigin);

    _RHReferences rh(result,includeQualifiers ,includeClassOrigin ,propertyList );
    doReferences(env, rh, ns, objectName, theAssocClass, "", role, "");
}
void
    CppSimpleAssociatorProviderIFC::referenceNames(const ProviderEnvironmentIFCRef &env,
                                                   CIMObjectPathResultHandlerIFC &result,
                                                   const String &ns,
                                                   const CIMObjectPath &objectName,
                                                   const String &resultClass,
                                                   const String &role)
{

    CIMOMHandleIFCRef lch = env->getCIMOMHandle();
    CIMClass theAssocClass = lch->getClass(ns, resultClass);
    _RHReferenceNames rh(result,ns);
    doReferences(env, rh,ns ,objectName , theAssocClass,"",role, "");
}

}

---