Base.h

Go to the documentation of this file.

/******************************************************************************
*       SOFA, Simulation Open-Framework Architecture, version 1.0 beta 3      *
*                (c) 2006-2008 MGH, INRIA, USTL, UJF, CNRS                    *
*                                                                             *
* This library is free software; you can redistribute it and/or modify it     *
* under the terms of the GNU Lesser General Public License as published by    *
* the Free Software Foundation; either version 2.1 of the License, or (at     *
* your option) any later version.                                             *
*                                                                             *
* 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 GNU Lesser General Public License *
* for more details.                                                           *
*                                                                             *
* You should have received a copy of the GNU Lesser General Public License    *
* along with this library; if not, write to the Free Software Foundation,     *
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA.          *
*******************************************************************************
*                              SOFA :: Framework                              *
*                                                                             *
* Authors: M. Adam, J. Allard, B. Andre, P-J. Bensoussan, S. Cotin, C. Duriez,*
* H. Delingette, F. Falipou, F. Faure, S. Fonteneau, L. Heigeas, C. Mendoza,  *
* M. Nesme, P. Neumann, J-P. de la Plata Alcade, F. Poyer and F. Roy          *
*                                                                             *
* Contact information: contact@sofa-framework.org                             *
******************************************************************************/
#ifndef SOFA_CORE_OBJECTMODEL_BASE_H
#define SOFA_CORE_OBJECTMODEL_BASE_H

#include <sofa/helper/system/config.h>
#include <sofa/core/objectmodel/DataPtr.h>
#include <sofa/core/objectmodel/Data.h>
#include <sofa/core/objectmodel/BaseObjectDescription.h>
#include <string>

using sofa::core::objectmodel::DataPtr;
using sofa::core::objectmodel::Data;

namespace sofa
{

namespace core
{

namespace objectmodel
{

class Base
{
public:
    Base();
    virtual ~Base();
    
    Data<std::string> name;

    std::string getName() const;
    
    void setName(const std::string& n);
    
    virtual std::string getTypeName() const
    {
        return decodeTypeName(typeid(*this));
    }
    
    virtual std::string getClassName() const
    {
        return decodeClassName(typeid(*this));
    }
    
    virtual std::string getTemplateName() const
    {
        return decodeTemplateName(typeid(*this));
    }
    
    static std::string decodeTypeName(const std::type_info& t);
    
    static std::string decodeClassName(const std::type_info& t);
    
    static std::string decodeNamespaceName(const std::type_info& t);
    
    static std::string decodeTemplateName(const std::type_info& t);
    
    template<class T>
    static std::string typeName(const T* = NULL)
    {
        return decodeTypeName(typeid(T));
    }
    
    template<class T>
    static std::string className(const T* = NULL)
    {
        return decodeClassName(typeid(T));
    }
    
    template<class T>
    static std::string namespaceName(const T* = NULL)
    {
        return decodeNamespaceName(typeid(T));
    }
    
    template<class T>
    static std::string templateName(const T* = NULL)
    {
        return decodeTemplateName(typeid(T));
    }

    void parseFields ( std::list<std::string> str );
    
    virtual void parseFields ( const std::map<std::string,std::string*>& str );
    
    void writeDatas (std::map<std::string,std::string*>& str);
    
    void writeDatas (std::ostream& out);
       
    void xmlWriteNodeDatas (std::ostream& out, unsigned level);
    
    void xmlWriteDatas (std::ostream& out, unsigned level);
    
    unsigned int findField( const char* name ) const
    {
        std::string ln(name);
    unsigned int i;
    for ( i=0;i<m_fieldVec.size();i++)
    {
        if (m_fieldVec[i].first == ln) return i;
    }
    return i;
    }
    unsigned int findField( const std::string &name ) const
    {
    unsigned int i;
    for ( i=0;i<m_fieldVec.size();i++)
    {
        if (m_fieldVec[i].first == name) return i;
    }
    return i;
    }
    template<class T>
    Data<T> initData( Data<T>* field, const char* name, const char* help, bool isDisplayed=true )
    {
        std::string ln(name);
        if( ln.size()>0 && findField(ln)!=m_fieldVec.size() )
        {
            std::cerr << "field name " << ln << " already used in this class or in a parent class !...aborting" << std::endl;
            exit( 1 );
        }
        //field = tmp;
    m_fieldVec.push_back( std::make_pair(ln,field));
    return Data<T>(help,isDisplayed);
    }
    
    template<class T>
    Data<T> initData( Data<T>* field, const T& value, const char* name, const char* help, bool isDisplayed=true  )
    {
        std::string ln(name);
        if( ln.size()>0 && findField(ln)!=m_fieldVec.size()  )
        {
            std::cerr << "field name " << ln << " already used in this class or in a parent class !...aborting" << std::endl;
            exit( 1 );
        }
        //field = tmp;
    m_fieldVec.push_back( std::make_pair(ln,field));
        return Data<T>(value,help,isDisplayed);
    }
    
    template<class T>
    DataPtr<T> initDataPtr( DataPtr<T>* field, T* ptr, const char* name, const char* help, bool isDisplayed=true  )
    {
        std::string ln(name);
        if( ln.size()>0 && findField(ln)!=m_fieldVec.size() )
        {
            std::cerr << "field name " << ln << " already used in this class or in a parent class !...aborting" << std::endl;
            exit( 1 );
        }
        //field = tmp;
    m_fieldVec.push_back( std::make_pair(ln,field));
    return DataPtr<T>(ptr,help,isDisplayed);
    }


    virtual void parse ( BaseObjectDescription* arg );

    std::vector< std::pair<std::string, BaseData*> > getFields() { return m_fieldVec; }

protected:
    std::vector< std::pair<std::string, BaseData*> > m_fieldVec;
    
    void addField( BaseData* f, const char* name )
    {
        std::string ln(name);
        if( ln.size()>0 && findField(ln)!=m_fieldVec.size() )
        {
            std::cerr << "field name " << ln << " already used in this class or in a parent class !...aborting" << std::endl;
            exit( 1 );
        }
    m_fieldVec.push_back( std::make_pair(ln,f));
    }
};

} // namespace objectmodel

} // namespace core

} // namespace sofa

#endif