/* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2006 Robert Osfield 
 *
 * This library is open source and may be redistributed and/or modified under  
 * the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or 
 * (at your option) any later version.  The full license is in LICENSE file
 * included with this distribution, and on the openscenegraph.org website.
 * 
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the 
 * OpenSceneGraph Public License for more details.
*/
//osgIntrospection - Copyright (C) 2005 Marco Jez

#ifndef OSGINTROSPECTION_UTILITY_
#define OSGINTROSPECTION_UTILITY_

#include <osgIntrospection/Export>
#include <osgIntrospection/Value>
#include <osgIntrospection/ParameterInfo>
#include <osgIntrospection/MethodInfo>
#include <osgIntrospection/variant_cast>

#include <vector>

namespace osgIntrospection
{

    bool OSGINTROSPECTION_EXPORT areParametersCompatible(const ParameterInfoList& pl1, const ParameterInfoList& pl2);
    bool OSGINTROSPECTION_EXPORT areArgumentsCompatible(const ValueList& vl, const ParameterInfoList& pl, float &match);
    
    template<typename T>
    void convertArgument(ValueList& src, ValueList& dest, const ParameterInfoList& pl, int index)
    {
        if (index >= static_cast<int>(src.size()))
        {
            dest[index] = pl[index]->getDefaultValue();
        }
        else
        {
            Value& sv = src[index];
            if (requires_conversion<T>(sv))
                dest[index] = sv.convertTo(pl[index]->getParameterType());
            else
                dest[index].swap(sv);
        }
    }


    /// Return a const reference on the reflected value given on the instance
    ///
    /// NOTE: You should NEVER paste a pointer or a reference to the template parameter T
    template<typename T> const T &getInstance(const Value &instance)
    {
        return instance.isTypedPointer() ?
            *variant_cast<const T*>(instance) : variant_cast<const T&>(instance);
    }
    
    /// Return a reference on the reflected value given on the instance
    ///
    /// NOTE: You should NEVER paste a pointer or a reference to the template parameter T
    template<typename T> T &getInstance(Value &instance)
    {
        return instance.isTypedPointer() ?
            *variant_cast<T*>(instance) : variant_cast<T&>(instance);
    }

}

#endif