b2object.H

Go to the documentation of this file.

//------------------------------------------------------------------------
// b2object.H --
//
//
// written by Mathias Doreille
//            Neda Ebrahimi Pour <neda.ebrahimipour@dlr.de>
//            Harald Klimach <harald.klimach@dlr.de>
//            Thomas Blome <thomas.blome@dlr.de>
//
// (c) 2004-2012 SMR Engineering & Development SA
//               2502 Bienne, Switzerland
//
// (c) 2023 Deutsches Zentrum für Luft- und Raumfahrt (DLR) e.V.
//          Linder Höhe, 51147 Köln
//
// All Rights Reserved.  Proprietary source code.  The contents of
// this file may not be disclosed to third parties, copied or
// duplicated in any form, in whole or in part, without the prior
// written permission of SMR.
//------------------------------------------------------------------------
 
#ifndef __B2OBJECT_H__
#define __B2OBJECT_H__
 
// This text is now in the B2000++ Programming Manual
 
#include <map>
#include <sstream>
#include <string>
 
#include "b2ppconfig.h"
#include "utils/b2allocator.H"
#include "utils/b2exception.H"
#include "utils/b2module.H"
#include "utils/b2util.H"
 
namespace b2000 {
 
class ObjectType;
class Object;
 
inline std::ostream& operator<<(std::ostream& o, const ObjectType& m);
 
class ObjectType {
public:
    ObjectType(
          const std::string& name_, const std::string& suffix = "",
          const StringList& aliases = StringList(), Module& module_ = b2000_module,
          ObjectType* base_type_ = nullptr, const char* doc_ = nullptr)
        : name(name_),
          suffix(suffix),
          module(module_),
          base_type(base_type_),
          doc(doc_),
          aliases(aliases) {
        module.set_object_type(this, name + suffix, aliases, suffix);
    }
 
    virtual ~ObjectType() {}
 
    const std::string get_name() const { return name + suffix; }
 
    bool normalize_name(std::string& identifier) const {
        bool matching = identifier == name;
        auto alias = aliases.begin();
        while (!matching && alias != aliases.end()) {
            matching = (*alias == identifier);
            alias++;
        }
        if (matching) { identifier = get_name(); }
 
        return matching;
    }
 
    virtual const std::string get_cpp_name() const { return "??"; }
 
    virtual Object* new_object() {
        TypeError() << "This object type is incomplete." << THROW;
        return nullptr;
    }
 
    virtual Object* new_object(Allocator& allocator) {
        TypeError() << "This object type is incomplete." << THROW;
        return nullptr;
    }
 
    virtual bool is_type(const Object* o) { return typeid(o) == typeid(const Object*); }
 
    inline virtual bool is_subtype(const Object* o) { return true; }
 
    virtual ObjectType* get_subtype(const std::string& name_, Module& module_ = b2000_module) {
        return module_.get_object_type(name_);
    }
 
private:
    const std::string name;
    const std::string suffix;
    Module& module;
    ObjectType* base_type;
    const char* doc;
    StringList aliases;
 
    using children_t = std::map<std::string, ObjectType*>;
    children_t children;
 
    // The copy and the heap allocation ob ObjectType are forbidden.
    // These members are declared private.
    ObjectType(const ObjectType&);
};
 
inline std::ostream& operator<<(std::ostream& o, const ObjectType& ot) {
    return o << ot.get_name() << " (c++ type=" << ot.get_cpp_name() << ")";
}
 
template <typename OBJECT, typename BASE_OBJECT_TYPE = ObjectType>
class ObjectTypeIncomplete : public BASE_OBJECT_TYPE {
public:
    ObjectTypeIncomplete(
          const std::string& name_, const std::string& suffix,
          const StringList& aliases = StringList(), Module& module_ = b2000_module,
          ObjectType* base_type_ = nullptr, const char* doc_ = nullptr)
        : BASE_OBJECT_TYPE(name_, suffix, aliases, module_, base_type_, doc_) {}
 
    OBJECT* new_object() {
        TypeError() << "Cannot create an object of type " << *this
                    << " because this type is incomplete." << THROW;
        return 0;
    }
 
    OBJECT* new_object(Allocator& allocator) {
        TypeError() << "Cannot create an object of type " << *this
                    << " because this type is incomplete." << THROW;
        return 0;
    }
 
    const std::string get_cpp_name() const { return demangle(typeid(OBJECT)); }
 
    bool is_type(const Object* o) { return typeid(o) == typeid(const OBJECT*); }
 
    bool is_subtype(const Object* o) {
        UnimplementedError() << THROW;
        return false;  // dynamic_cast<const OBJECT*>(o) != 0;
    }
 
    ObjectTypeIncomplete* get_subtype(const std::string& name_, Module& module_ = b2000_module) {
        ObjectType* ot = module_.get_object_type(name_);
        if (ot == nullptr) {
            KeyError() << "The type " << name_ << " is not a type of the module \"" << module_
                       << "\"." << THROW;
        }
        ObjectTypeIncomplete* o = dynamic_cast<ObjectTypeIncomplete*>(ot);
        if (o == 0) {
            KeyError() << "The type " << *ot << " is not a subtype of the type " << *this << "."
                       << THROW;
        }
        return o;
    }
};
 
template <typename OBJECT, typename BASE_OBJECT_TYPE = ObjectType>
class ObjectTypeComplete : public BASE_OBJECT_TYPE {
public:
    ObjectTypeComplete(
          const std::string& name_, const std::string& suffix,
          const StringList& aliases = StringList(), Module& module_ = b2000_module,
          ObjectType* base_type_ = nullptr, const char* doc_ = nullptr)
        : BASE_OBJECT_TYPE(name_, suffix, aliases, module_, base_type_, doc_) {}
 
    OBJECT* new_object() { return new OBJECT{}; }
 
    OBJECT* new_object(Allocator& allocator) {
        return new (allocator.allocate(sizeof(OBJECT))) OBJECT{};
    }
 
    const std::string get_cpp_name() const { return demangle(typeid(OBJECT)); }
 
    bool is_type(const Object* o) { return typeid(o) == typeid(const OBJECT*); }
 
    bool is_subtype(const Object* o) {
        UnimplementedError() << THROW;
        return false;  // dynamic_cast<const OBJECT*>(o) != 0;
    }
 
    ObjectTypeComplete* get_subtype(const std::string& name_, Module& module_ = b2000_module) {
        ObjectType* ot = module_.get_object_type(name_);
        if (ot == nullptr) {
            KeyError() << "The type " << name_ << " is not a type of the module \"" << module_
                       << "\"." << THROW;
        }
        ObjectTypeComplete* o = dynamic_cast<ObjectTypeComplete*>(ot);
        if (o == 0) {
            KeyError() << "The type " << *ot << " is not a subtype of the type " << *this << "."
                       << THROW;
        }
        return o;
    }
};
 
class Object {
public:
    virtual const std::string& get_object_name() const { return unknown_object_name; }
 
    virtual ~Object(){};
 
    virtual void incref() const {}
 
    virtual void decref() const {}
 
    virtual void free() { this->~Object(); }
 
    virtual void decref_or_free() const { this->~Object(); }
 
    static ObjectType type;
 
private:
    static std::string unknown_object_name;
};
 
inline std::string type_name(const std::string& s = "") { return s; }
 
template <typename T1>
inline std::string type_name(const std::string& s = "") {
    return s + '<' + demangle(typeid(T1)) + '>';
}
 
template <typename T1, typename T2>
inline std::string type_name(const std::string& s = "") {
    return s + '<' + demangle(typeid(T1)) + "," + demangle(typeid(T2)) + '>';
}
 
template <typename T1, typename T2, typename T3>
inline std::string type_name(const std::string& s = "") {
    return s + '<' + demangle(typeid(T1)) + "," + demangle(typeid(T2)) + "," + demangle(typeid(T3))
           + '>';
}
 
template <typename T1, typename T2, typename T3, typename T4>
inline std::string type_name(const std::string& s = "") {
    return s + '<' + demangle(typeid(T1)) + "," + demangle(typeid(T2)) + "," + demangle(typeid(T3))
           + "," + demangle(typeid(T4)) + '>';
}
 
}  // namespace b2000
 
#endif