class_name_provider.h

Go to the documentation of this file.

/*
 * Copyright (c) 2010-2015:  G-CSC, Goethe University Frankfurt
 * Authors: Sebastian Reiter, Andreas Vogel
 * 
 * This file is part of UG4.
 * 
 * UG4 is free software: you can redistribute it and/or modify it under the
 * terms of the GNU Lesser General Public License version 3 (as published by the
 * Free Software Foundation) with the following additional attribution
 * requirements (according to LGPL/GPL v3 §7):
 * 
 * (1) The following notice must be displayed in the Appropriate Legal Notices
 * of covered and combined works: "Based on UG4 (www.ug4.org/license)".
 * 
 * (2) The following notice must be displayed at a prominent place in the
 * terminal output of covered works: "Based on UG4 (www.ug4.org/license)".
 * 
 * (3) The following bibliography is recommended for citation and must be
 * preserved in all covered files:
 * "Reiter, S., Vogel, A., Heppner, I., Rupp, M., and Wittum, G. A massively
 *   parallel geometric multigrid solver on hierarchically distributed grids.
 *   Computing and visualization in science 16, 4 (2013), 151-164"
 * "Vogel, A., Reiter, S., Rupp, M., Nägel, A., and Wittum, G. UG4 -- a novel
 *   flexible software system for simulating pde based models on high performance
 *   computers. Computing and visualization in science 16, 4 (2013), 165-179"
 * 
 * This program 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.
 */
 
 
#ifndef __H__UG_BRIDGE__CLASS_NAME_PROVIDER__
#define __H__UG_BRIDGE__CLASS_NAME_PROVIDER__
 
#include "common/assert.h"
#include <vector>
#include <cstring>
#include <string>
#include <algorithm>
#include <iostream>
#include <typeinfo>
#include <map>
#include "common/common.h"
#include "common/util/smart_pointer.h"
#include "common/ug_config.h"
#include "error.h"
 
namespace ug
{
namespace bridge
{
 
 
 
class UG_API ClassNameNode
{
  public:
    ClassNameNode();
 
    void set_name(const std::string& name);
 
    void add_base_class(const ClassNameNode& node);
 
    const std::string& name() const {return m_name;}
 
    bool empty() const {return m_name.empty();}
 
    bool named() const;
 
    size_t num_base_classes() const {return m_vBaseClass.size();}
 
    const ClassNameNode& base_class(size_t i) const {return *m_vBaseClass.at(i);}
 
  protected:
    std::string m_name;
 
    std::vector<const ClassNameNode*> m_vBaseClass;
};
 
template <typename TClass>
class UG_API ClassNameProvider
{
  public:
    static void set_name(const std::string& nameIn, const std::string& group,
                         bool newName = false);
 
    template <typename TParent1>
    static void set_name(const std::string& nameIn, const std::string& group,
                         bool newName = false);
 
    template <typename TParent1, typename TParent2>
    static void set_name(const std::string& nameIn, const std::string& group,
                         bool newName = false);
 
    static bool is_a(const std::string& parent, bool strict = false);
 
    static const std::string& name();
 
    static const std::string& group(){return m_group;}
 
    static const std::vector<const char*>& names();
 
    static const ClassNameNode& class_name_node() {return m_ClassNameNode;}
 
    static bool forward_declared() {return m_bForwardDeclared;}
 
    static bool named() {return !m_bForwardDeclared && !m_ClassNameNode.empty();}
 
  protected:
    static void set_foreward_declared();
 
  private:
    static std::vector<const char*> m_names;
 
    static std::string m_group;
 
    static bool m_bForwardDeclared;
 
    static ClassNameNode m_ClassNameNode;
};
 
template <typename TClass>
const char* GetClassName(){
  return ClassNameProvider<TClass>::name().c_str();
}
 
template <typename TBase, typename TDerived>
void* StaticVoidCast(void* DerivVoidPtr);
 
 
struct UGError_ClassCastFailed : public UGError{
  UGError_ClassCastFailed(const std::string& from, const std::string& to) :
    UGError("Class cast failed"), m_from(from), m_to(to)  {}
 
  std::string m_from;
  std::string m_to;
};
 
class ClassCastProvider
{
  public:
    template <typename TBase, typename TDerived>
    static void add_cast_func();
 
 
    static void* cast_to_base_class(void* pDerivVoid,
                                    const ClassNameNode*& node,
                                    const std::string& baseName);
    static const void* cast_to_base_class(const void* pDerivVoid,
                                          const ClassNameNode*& node,
                                          const std::string& baseName);
 
 
    template <typename T>
    static T* cast_to(void* pDerivVoid, const ClassNameNode*& node);
    template <typename T>
    static const T* cast_to(const void* pDerivVoid, const ClassNameNode*& node);
    template <typename T>
    static SmartPtr<T> cast_to(SmartPtr<void> pDerivVoid, const ClassNameNode*& node);
    template <typename T>
    static ConstSmartPtr<T> cast_to(ConstSmartPtr<void> pDerivVoid, const ClassNameNode*& node);
 
  protected:
  //  type of cast pointer
    typedef void* (*CastFunc)(void*);
 
  //  cast map
    static std::map<std::pair<const ClassNameNode*, const ClassNameNode*>, CastFunc> m_mmCast;
};
 
 
void ExtractClassNameVec(std::vector<const char*>& names,
                         const ClassNameNode& node,
                         bool clearVec = true);
 
bool ClassNameVecContains(const std::vector<const char*>& names, const std::string& name);
 
bool ClassNameTreeContains(const ClassNameNode& node, const std::string& name);
 
bool ClassNameTreeWay(std::vector<size_t>& vWay, const ClassNameNode& node, const std::string& name);
 
// end group registry
 
} // end namespace
} // end namespace
 
// include implementation
#include "class_name_provider_impl.h"
 
#endif /* __H__UG_BRIDGE__CLASS_NAME_PROVIDER__ */