each subclass should instantiates their logger

[maureeungaro]

• gbase class constructed with the shared_ptr goptions and having a member shared_ptr

• make new shared_ptr everywhere in the examples. also check if we should use optional as in GDynamicDigitization

• no class should instantiate extra GLogger - examples may duplicate it

• LoadAndRegisterObjectFromLibrary should also use shared_ptr

• gfactory, check if we can initialize with GOptions and remove set_loggers

• gtouchable

• gtranslationTable

• gdata

• gdynamicDigitization

• eventDispenser

• gQtButtonsWidget

• g4display

• g4dialog

• gsystem

• g4system

• gparticle

• gphysics

• gsplash

• gstreamer

• gsd

• gfields

• gdetector

• userActions

• dbselect

[maureeungaro]

Example code with class name introspection. gbase could have gopts and log, and constructor from shared_ptr

#include <iostream>
#include <string>
#include <typeinfo>

#if defined(__GNUG__)
#include <cxxabi.h>
#include <memory>

std::string demangle(const char* name) {
    int status = 0;
    std::unique_ptr<char, void(*)(void*)> demangled{
        abi::__cxa_demangle(name, nullptr, nullptr, &status),
        std::free
    };
    return (status == 0 && demangled) ? demangled.get() : name;
}
#else
std::string demangle(const char* name) {
    return name; // No demangling on non-GNU compilers
}
#endif

class g1 {
    int object1;
};

class g2 {
public:
    virtual ~g2() = default;

    std::string getClassName() const {
        return demangle(typeid(*this).name());
    }
};

class gbase : public g1, public g2 {
    int object2;
};

int main() {
    gbase obj;
    g2* ptr = &obj;
    std::cout << "Derived class name: " << ptr->getClassName() << '\n';
}

[maureeungaro]

can use:

#if defined(__clang__) || defined(__GNUC__)
  #define FUNCTION_NAME __PRETTY_FUNCTION__
#elif defined(_MSC_VER)
  #define FUNCTION_NAME __FUNCSIG__
#else
  #define FUNCTION_NAME __func__ // fallback
#endif

example:

class A {
public:
void hello() {
std::cout << "Function name: " << func << std::endl;
std::cout << "Pretty function: " << PRETTY_FUNCTION << std::endl; // GCC/Clang
}
};

int main() {
A a;
a.hello();
}

[maureeungaro]

PRETTY_FUNCTION may be used outside in the log-> calls - that is ok!

what about the define_options ? maybe it can be virtual automatic ?

[maureeungaro]

check if

log->debug(DESTRUCTOR, FUNCTION_NAME);

can be called in the base class