xref: /trunk/main/xmloff/source/chart/MultiPropertySetHandler.hxx (revision 914d351e5f5b84e4342a86d6ab8d4aca7308b9bd)

/**************************************************************
 *
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 *
 *************************************************************/



#ifndef _MULTI_PROPERTY_SET_HANDLER_HXX
#define _MULTI_PROPERTY_SET_HANDLER_HXX

#include    <rtl/ustring.hxx>
#include <com/sun/star/beans/XPropertySet.hpp>
#include <com/sun/star/beans/XMultiPropertySet.hpp>


/** @descr  MultiPropertySetHandler handles the two slightly different
        interfaces XPropertySet and XMultiPropertySet for accessing
        properties of an object.

        It uses the classes PropertyWrapperBase and the template
        PropertyWrapper for a type safe access to single properties.

        The function class OUStringComparison is used by a STL map to
        sort the properties by names.
*/

/** @descr  Base class for the templated property wrappers.
        Having a common base class allows to set a variable to the
        property's value without explicit knowledge of its type.
*/
class   PropertyWrapperBase
{
public:
    /** @descr  Create a class instance and store the given name.
        @param  rName   The name of the property.
    */
    PropertyWrapperBase (const ::rtl::OUString & rName)
        :   msName (rName)
    {}
    virtual ~PropertyWrapperBase()
    {}

    /** @descr  Abstract interface of a method for setting a variables
            value to that of the property.
    */
    virtual void    SetValue    (const ::com::sun::star::uno::Any & rValue) = 0;

    const ::rtl::OUString msName;
};




/** @descr  For every property type there will be one instantiation of this
        template class with its own and type specific version of SetValue.
*/
template<class T> class PropertyWrapper : public PropertyWrapperBase
{
public:
    /** @descr  Create a wrapper for a property of type T.
    */
    PropertyWrapper (const ::rtl::OUString & rName, T & rValue)
        :   PropertyWrapperBase (rName),
            mrValue (rValue)
    {}

    /** descr   Set the given value inside an Any to the variable referenced
        by the data member.
    */
    virtual void    SetValue    (const ::com::sun::star::uno::Any & rValue)
    {
        rValue >>= mrValue;
    }

private:
    /// Reference to a variable.  Its value can be modified by a call to SetValue.
    T   &   mrValue;
};




/** @descr  Function object for comparing two OUStrings.
*/
class   OUStringComparison
{
public:
    /// Compare two strings.  Returns true if the first is before the second.
    inline  bool    operator()  (const ::rtl::OUString & a, const ::rtl::OUString & b) const
    {
        return (a.compareTo (b) < 0);
    }
};




/** @descr  This class lets you get the values from an object that either
        supports the interface XPropertySet or XMultiPropertySet.  If it
        supports both interfaces then XMultiPropertySet is preferred.

        Using it works in three steps.
        1.  Create an instance and pass a reference to the object from which to
            get the property values.
        2.  Make all properties whose values you want to get known to the object
            by using the Add method.  This creates instances of a template class
            that stores the properties name and a reference to the variable in
            which to store its value.
        3.  Finally call GetProperties to store the properties values into the
            variables specified in step 2.  This uses either the XPropertySet or
            (preferred) the XMultiPropertySet interface.
*/
class   MultiPropertySetHandler
{
public:
    /** @descr  Create a handler of the property set of the given
            object.
        @param  xObject A reference to any of the object's interfaces.
            not necessarily XPropertySet or XMultiPropertySet.  It
            is casted later to one of the two of them.
    */
    MultiPropertySetHandler (::com::sun::star::uno::Reference<
        ::com::sun::star::uno::XInterface> xObject);
    ~MultiPropertySetHandler    (void);
    /** @descr  Add a property to handle.  The type given implicitly by the
            reference to a variable is used to create an instance of
            the PropertyWrapper template class.
        @param  sName   Name of the property.
        @param  rValue  Reference to a variable whose value is set by the
            call to GetProperties to the property's value.
    */
    template<class T> void  Add (const ::rtl::OUString & sName, T& rValue)
    {
        aPropertyList[sName] = new PropertyWrapper<T> (sName, rValue);
    }

    /** @descr  Try to get the values for all properties added with the Add
            method.  If possible it uses the XMultiPropertySet.  If that fails
            (i.e. for an UnknownPropertyExcption) or if the interface is not
            supported it uses the XPropertySet interface.
        @return If none of the two interfaces is supported or using them both
            fails then sal_False is returned.  Else True is returned.
    */
    inline  sal_Bool    GetProperties   (void);

private:
    /** @descr  Try to use the XMultiPropertySet interface to get the property
            values.
        @param  rNameList   A precomputed and sorted sequence of OUStrings
            containing the properties names.
        @return True if values could be derived.
    */
    inline  sal_Bool    MultiGet    (const ::com::sun::star::uno::Sequence<
        ::rtl::OUString> & rNameList);

    /** @descr  Try to use the XPropertySet interface to get the property
            values.
        @param  rNameList   A precomputed and sorted sequence of OUStrings
            containing the properties names.
        @return True if values could be derived.
    */
    inline  sal_Bool    SingleGet   (const ::com::sun::star::uno::Sequence<
        ::rtl::OUString> & rNameList);

    /** @descr  STL map that maps from property names to polymorphic instances of
            PropertyWrapper.  It uses OUStringComparison for sorting
            the property names.
    */
    ::std::map< ::rtl::OUString, PropertyWrapperBase*, OUStringComparison> aPropertyList;

    /// The object from which to get the property values.
    ::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface>    mxObject;
};



//=====  Inline implementation of the methods declared above  ==========================

MultiPropertySetHandler::MultiPropertySetHandler (::com::sun::star::uno::Reference<
    ::com::sun::star::uno::XInterface> xObject)
        :   mxObject (xObject)
{
}




MultiPropertySetHandler::~MultiPropertySetHandler (void)
{
    ::std::map< ::rtl::OUString, PropertyWrapperBase*, OUStringComparison>::iterator I;
    for (I=aPropertyList.begin(); I!=aPropertyList.end(); I++)
        delete I->second;
}


/*
template<class T> void  MultiPropertySetHandler::Add (const ::rtl::OUString & sName, T& pValue)
{
    aPropertyList[sName] = new PropertyWrapper<T> (sName, pValue);
}
*/



sal_Bool    MultiPropertySetHandler::GetProperties  (void)
{
    ::std::map< ::rtl::OUString, PropertyWrapperBase*, OUStringComparison>::iterator I;
    ::com::sun::star::uno::Sequence< ::rtl::OUString> aNameList (aPropertyList.size());
    int i;
    for (I=aPropertyList.begin(),i=0; I!=aPropertyList.end(); I++)
        aNameList[i++] = I->second->msName;
    if ( ! MultiGet(aNameList))
        if ( ! SingleGet(aNameList))
            return sal_False;
    return sal_True;
}




sal_Bool    MultiPropertySetHandler::MultiGet   (const ::com::sun::star::uno::Sequence<
    ::rtl::OUString> & rNameList)
{
    ::com::sun::star::uno::Reference< ::com::sun::star::beans::XMultiPropertySet> xMultiSet (
        mxObject, ::com::sun::star::uno::UNO_QUERY);
    if (xMultiSet.is())
        try
        {
            ::std::map< ::rtl::OUString, PropertyWrapperBase*, OUStringComparison>::iterator I;
            int i;
            ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Any> aValueList =
                xMultiSet->getPropertyValues (rNameList);
            for (I=aPropertyList.begin(),i=0; I!=aPropertyList.end(); I++)
                I->second->SetValue (aValueList[i++]);
        }
        catch (::com::sun::star::beans::UnknownPropertyException e)
        {
            return sal_False;
        }
    else
        return sal_False;

    return sal_True;
}




sal_Bool    MultiPropertySetHandler::SingleGet  (const ::com::sun::star::uno::Sequence<
    ::rtl::OUString> & rNameList)
{
    ::com::sun::star::uno::Reference< ::com::sun::star::beans::XPropertySet> xSingleSet (
        mxObject, ::com::sun::star::uno::UNO_QUERY);
    if (xSingleSet.is())
        try
        {
            ::std::map< ::rtl::OUString, PropertyWrapperBase*, OUStringComparison>::iterator I;
            int i;
            for (I=aPropertyList.begin(),i=0; I!=aPropertyList.end(); I++)
                I->second->SetValue (xSingleSet->getPropertyValue (rNameList[i++]));
        }
        catch (::com::sun::star::beans::UnknownPropertyException e)
        {
            return sal_False;
        }
    else
        return sal_False;

    return sal_True;
}


#endif