/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
 * This file is part of the LibreOffice project.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 *
 * This file incorporates work covered by the following license notice:
 *
 *   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 .
 */

#pragma once

#include <map>
#include <memory>
#include <string_view>

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

/** @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.
    */
    explicit PropertyWrapperBase (OUString aName)
        :   msName (std::move(aName))
    {}
    virtual ~PropertyWrapperBase()
    {}

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

    const 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 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 css::uno::Any & rValue) override
    {
        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.
    bool    operator()  (std::u16string_view a, std::u16string_view b) const
    {
        return (a.compare (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.
    */
    explicit MultiPropertySetHandler (css::uno::Reference<
        css::uno::XInterface> xObject);
    /** @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 OUString & sName, T& rValue)
    {
        aPropertyList[sName] = std::make_unique<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  bool    GetProperties();

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  bool    MultiGet    (const css::uno::Sequence<
        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  bool    SingleGet   (const css::uno::Sequence<
        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< OUString, std::unique_ptr<PropertyWrapperBase>, OUStringComparison> aPropertyList;

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

MultiPropertySetHandler::MultiPropertySetHandler (css::uno::Reference<
    css::uno::XInterface> xObject)
        :   mxObject (std::move(xObject))
{
}

bool    MultiPropertySetHandler::GetProperties()
{
    css::uno::Sequence< OUString> aNameList (aPropertyList.size());
    auto aNameListRange = asNonConstRange(aNameList);
    int i = 0;
    for (const auto& rProperty : aPropertyList)
        aNameListRange[i++] = rProperty.second->msName;
    if ( ! MultiGet(aNameList))
        if ( ! SingleGet(aNameList))
            return false;
    return true;
}

bool    MultiPropertySetHandler::MultiGet   (const css::uno::Sequence<
    OUString> & rNameList)
{
    css::uno::Reference< css::beans::XMultiPropertySet> xMultiSet (
        mxObject, css::uno::UNO_QUERY);
    if (xMultiSet.is())
        try
        {
            int i = 0;
            css::uno::Sequence< css::uno::Any> aValueList =
                xMultiSet->getPropertyValues (rNameList);
            for (auto& rProperty : aPropertyList)
                rProperty.second->SetValue (aValueList[i++]);
        }
        catch (const css::beans::UnknownPropertyException&)
        {
            return false;
        }
    else
        return false;

    return true;
}

bool    MultiPropertySetHandler::SingleGet  (const css::uno::Sequence<
    OUString> & rNameList)
{
    css::uno::Reference< css::beans::XPropertySet> xSingleSet (
        mxObject, css::uno::UNO_QUERY);
    if (xSingleSet.is())
        try
        {
            int i = 0;
            for (auto& rProperty : aPropertyList)
                rProperty.second->SetValue (xSingleSet->getPropertyValue (rNameList[i++]));
        }
        catch (const css::beans::UnknownPropertyException&)
        {
            return false;
        }
    else
        return false;

    return true;
}

/* vim:set shiftwidth=4 softtabstop=4 expandtab: */