Class.h

Go to the documentation of this file.

/*
 * Copyright (C) 2012 by
 *   MetraLabs GmbH (MLAB), GERMANY
 * and
 *   Neuroinformatics and Cognitive Robotics Labs (NICR) at TU Ilmenau, GERMANY
 * All rights reserved.
 *
 * Contact: info@mira-project.org
 *
 * Commercial Usage:
 *   Licensees holding valid commercial licenses may use this file in
 *   accordance with the commercial license agreement provided with the
 *   software or, alternatively, in accordance with the terms contained in
 *   a written agreement between you and MLAB or NICR.
 *
 * GNU General Public License Usage:
 *   Alternatively, this file may be used under the terms of the GNU
 *   General Public License version 3.0 as published by the Free Software
 *   Foundation and appearing in the file LICENSE.GPL3 included in the
 *   packaging of this file. Please review the following information to
 *   ensure the GNU General Public License version 3.0 requirements will be
 *   met: http://www.gnu.org/copyleft/gpl.html.
 *   Alternatively you may (at your option) use any later version of the GNU
 *   General Public License if such license has been publicly approved by
 *   MLAB and NICR (or its successors, if any).
 *
 * IN NO EVENT SHALL "MLAB" OR "NICR" BE LIABLE TO ANY PARTY FOR DIRECT,
 * INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT OF
 * THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF "MLAB" OR
 * "NICR" HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * "MLAB" AND "NICR" SPECIFICALLY DISCLAIM ANY WARRANTIES, INCLUDING,
 * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
 * FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS
 * ON AN "AS IS" BASIS, AND "MLAB" AND "NICR" HAVE NO OBLIGATION TO
 * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS OR MODIFICATIONS.
 */

#ifndef _MIRA_CLASS_H_
#define _MIRA_CLASS_H_

#include <vector>
#include <map>
#include <cstdarg>

#ifndef Q_MOC_RUN
#include <boost/shared_ptr.hpp>
#endif

#include <thread/Thread.h>
#include <platform/Typename.h>
#include <utils/Foreach.h>
#include <error/Exception.h>
#include <serialization/SplitReflect.h>
#include <factory/TypeId.h>
#include <factory/Object.h>


namespace mira {


class Class;
class ClassProxy;
class Object;

typedef ClassProxy ClassPtr;

template <typename CLASS>
inline CLASS* mira_factoryDynamicCast( Object* base );


MIRA_DEFINE_EXCEPTION(XFactoryUnknown, Exception)
MIRA_DEFINE_EXCEPTION(XFactoryLogical, Exception)
MIRA_DEFINE_EXCEPTION(XFactoryBadCast, Exception)

// *****************************************************************************
// *** Class
// *****************************************************************************


class MIRA_BASE_EXPORT Class
{
    friend class ClassFactory;

    template<typename CLASS>
        friend class TClass;
    friend class ClassProxy;

public:
    virtual ~Class();

    virtual std::string const& getIdentifier() const;

    virtual std::string const& getName() const;

    virtual int getTypeId() const = 0;

    virtual Typename getTypename() const = 0;

    std::map<std::string, std::string> const& getMetaInfo() const;

    std::string const& getMetaInfo(const std::string& meta) const;

    virtual Object* newInstance() const = 0;

    template <class CLASS>
    CLASS* newInstance() const;

    virtual Object* newInstance( int paramCount, ... ) const = 0;

    virtual Object* newInstance( std::string const& childIdentifier ) const = 0;

    template <class CLASS>
    CLASS* newInstance( std::string const& childIdentifier ) const;

    virtual Object* newInstance( std::string const& childIdentifier,
                                 int paramCount, ... ) const = 0;

    bool isClassRegistered( std::string const& classIdentifier ) const;
    
    void eraseChild( Class const* const iClass );

    void eraseParent( Class const* const iClass );

    ClassProxy getClassByIdentifier(
            std::string const& classIdentifier ) const;

    std::vector<ClassProxy> getClassByMeta( std::string const& metaKey,
                                            std::string const& metaValue ) const;

    template <class T>
    std::vector<ClassProxy> getClassByMeta( T funcPtr ) const;

    std::map<std::string, ClassProxy> getDerivedClasses() const;

    std::map<std::string, ClassProxy> getDirectParents() const;

    bool isBaseOf( Class const* const derived ) const;

    bool isBaseOf( ClassProxy derived ) const;

    bool isBaseOf( std::string const& identifier ) const;

    bool isDerivedFrom( Class const* const base ) const;

    bool isDerivedFrom( ClassProxy base ) const;

    bool isDirectlyDerivedFrom( Class const* const base ) const;

    bool isDirectlyDerivedFrom( ClassProxy base ) const;

    bool isDeclaredAbstract() const;

    virtual bool isAbstract() const = 0;

    bool isLibraryLoaded() const;

    MIRA_SPLIT_REFLECT_MEMBER

    template<typename Reflector>
    void reflectRead( Reflector& r );

    template<typename Reflector>
    void reflectWrite( Reflector& r );

    bool operator==(Class const& other) const {
        return this == &other;
    }

    bool operator!=(Class const& other) const {
        return this != &other;
    }
    
    bool operator <(Class const& other ) const {
        return mIdentifier < other.mIdentifier;
    }

protected:
    virtual Object* newVAInstance( int paramCount, std::va_list ) const = 0;

    Class( std::string const& identifier,
            std::string const& name,
            std::map<std::string, std::string> const& metaInfo,
            bool libLoaded );

    Class ( std::string const& identifier, std::string const& name,
            bool libLoaded );

private:
    Class() {}

protected:
    std::map<std::string, ClassProxy > mDerivedChildren;
    std::map<std::string, ClassProxy> mDirectParents; 
    std::string mIdentifier;                          
    std::string mName;                                
    std::string mLib;                                 
    std::map<std::string, std::string> mMetaInfo;     
    bool mLibLoaded;                                  
};

class MIRA_BASE_EXPORT ClassProxy
{
    friend class ClassFactory;
    friend class VacantClass;
    friend class Class;

    template<typename CLASS>
        friend class TClass;

public:
    ClassProxy() : mClass( NULL ), mThreadMutex( NULL )
    {
    }

    ClassProxy( ClassProxy const& other )
    {
        mClass = other.mClass;
        mThreadMutex = other.mThreadMutex;
    }

    bool operator== (ClassProxy const& other ) const {
        if ( !mClass || !*mClass || !other.mClass || !*other.mClass )
            MIRA_THROW( XFactoryLogical, "ClassProxy invalid!" );
        return **other.mClass == **mClass;
    }

    bool operator!= (ClassProxy const& other ) const {
        if ( !mClass || !*mClass || !other.mClass || !*other.mClass )
            MIRA_THROW( XFactoryLogical, "ClassProxy invalid!" );
        return **other.mClass != **mClass;
    }

    bool operator <(ClassProxy const& other ) const {
        if ( !mClass || !*mClass || !other.mClass || !*other.mClass )
            MIRA_THROW( XFactoryLogical, "ClassProxy invalid!" );
        return **mClass < **other.mClass;
    }

    std::string const& getIdentifier() const;

    std::string const& getName() const;

    int getTypeId() const;

    Typename getTypename() const;

    std::map<std::string, std::string> const& getMetaInfo() const;

    std::string const& getMetaInfo(const std::string& meta) const;

    Object* newInstance() const;

    template <class CLASS>
    CLASS* newInstance() const
    {
        boost::recursive_mutex::scoped_lock lock( *mThreadMutex );
        return (*mClass)->newInstance<CLASS>();
    }

     Object* newInstance( int paramCount, ... ) const;

    Object* newInstance( std::string const& childIdentifier ) const;

    template <class CLASS>
    CLASS* newInstance( std::string const& childIdentifier ) const
    {
        boost::recursive_mutex::scoped_lock lock( *mThreadMutex );
        return (*mClass)->newInstance<CLASS>( childIdentifier );
    }

    Object* newInstance( std::string const& childIdentifier,
            int paramCount, ... ) const;

    bool isClassRegistered( std::string const& classIdentifier ) const;
    
    void eraseChild( Class const* const iClass );

    void eraseParent( Class const* const iClass );

    ClassProxy getClassByIdentifier(std::string const& classIdentifier ) const;

    std::vector<ClassProxy> getClassByMeta(std::string const& metaKey,
                                           std::string const& metaValue ) const;

    template <class T>
    std::vector<ClassProxy> getClassByMeta( T funcPtr ) const
    {
        boost::recursive_mutex::scoped_lock lock( *mThreadMutex );
        return (*mClass)->getClassByMeta( funcPtr );
    }

    std::map<std::string, ClassProxy > getDerivedClasses() const;

    std::map<std::string, ClassProxy > getDirectParents() const;

    bool isBaseOf( Class const* const derived ) const;

    bool isBaseOf( ClassProxy derived ) const;

    bool isBaseOf( std::string const& identifier ) const;

    bool isDerivedFrom( Class const* const base ) const;

    bool isDerivedFrom( ClassProxy base ) const;

    bool isDirectlyDerivedFrom( Class const* const base ) const;

    bool isDirectlyDerivedFrom( ClassProxy base ) const;

    bool isAbstract() const;

    bool isLibraryLoaded() const;

protected:
    Object* newVAInstance( int paramCount, std::va_list list ) const;

    ClassProxy( boost::shared_ptr<Class>* iClass );
    void setClass( boost::shared_ptr<Class>* iClass );

protected:
    boost::shared_ptr<Class>* mClass;
    boost::recursive_mutex* mThreadMutex;
};


// *****************************************************************************
// *** ClassFactoryAbstractClassBuilder
// *****************************************************************************

struct ClassFactoryAbstractClassBuilder {

    template<typename CLASS>
    static CLASS* invoke( ) {
        MIRA_THROW( XFactoryLogical, "Cannot create abstract class ("
                    + CLASS::CLASS().getIdentifier() + ")!" );
        return NULL;
    }

    template<int N, typename CLASS>
    static CLASS* invoke( std::va_list ) {
        MIRA_THROW( XFactoryLogical, "Cannot create abstract class ("
                    + CLASS::CLASS().getIdentifier() + ")!" );
        return NULL;
    }
};

// *****************************************************************************
// *** ClassFactoryNoDefaultConstClassBuilder
// *****************************************************************************

struct ClassFactoryNoDefaultConstClassBuilder {
    template<typename CLASS>
    static CLASS* invoke( ) {
        MIRA_THROW( XFactoryLogical, "No public default constructor available for class"
                    "creation (" + CLASS::CLASS().getIdentifier() + ")!" );
        // go home
        return NULL;
    }
};

// *****************************************************************************
// *** ClassFactoryDefaultConstClassBuilder
// *****************************************************************************

struct ClassFactoryDefaultConstClassBuilder {

    template<typename CLASS>
    static CLASS* invoke( ) {
        return new CLASS;
    }

    template<int N, typename CLASS>
    static CLASS* invoke( std::va_list ) {
        MIRA_THROW( XFactoryLogical, "Desired parameter constructor not registered ("
                    + CLASS::CLASS().getIdentifier() + ")!" );
        return NULL;
    }
};


// *****************************************************************************
// *** Class implementation
// *****************************************************************************

template <class CLASS>
inline  CLASS* mira::Class::newInstance() const
{
    Object* tBase = newInstance();
    return mira_factoryDynamicCast<CLASS>( tBase );
}

template <class CLASS>
inline CLASS* mira::Class::newInstance( std::string const& childIdentifier ) const
{
    Object* tBase = newInstance( childIdentifier );
    return mira_factoryDynamicCast<CLASS>( tBase );
}

template <class T>
inline std::vector<ClassProxy> mira::Class::getClassByMeta( T funcPtr ) const
{
    std::vector<ClassProxy> tReturn;
    // apply matching function for each registered child
    std::map<std::string, ClassProxy >::const_iterator tIt = mDerivedChildren.begin();
    for( ; tIt != mDerivedChildren.end(); tIt++ ) {
        if ( funcPtr( tIt->second.getMetaInfo() ) ) {
            tReturn.push_back( tIt->second );
        }
    }
    return tReturn;
}




template<typename Reflector>
inline void mira::Class::reflectRead(Reflector& r)
{
    r.member( "Identifier" , mIdentifier, "" );
    r.member( "Name" , mName, "" );
    r.member( "Lib" , mLib, "" );
    r.member( "Meta" , mMetaInfo, "" );
    bool tAbstract = isAbstract();
    r.member( "Abstract", tAbstract, "" );
}

template<typename Reflector>
inline void mira::Class::reflectWrite(Reflector& r)
{
    r.member( "Identifier" , mIdentifier, "" );
    r.member( "Name" , mName, "" );
    r.member( "Lib" , mLib, "" );
    r.member( "Meta" , mMetaInfo, "" );
}

template <typename CLASS>
inline CLASS* mira_factoryDynamicCast( Object* base )
{
    CLASS* tClass = dynamic_cast<CLASS*> ( base );
    if ( !tClass ) {
        std::string tName = "NULL";
        if ( base ) {
            tName = base->getClass().getIdentifier();
        }
        delete base;
        MIRA_THROW( XFactoryBadCast, "You try to cast created object to incompatible"
                    " base class (" + tName + ")!");
    }
    return tClass;
}


} // namespace

#endif /* _MIRA_CLASS_H_ */