Refureku C++17 Runtime Reflection Library

Refureku allows you to attach custom metadata (similar to C# attributes) to any entity using a powerful property system.

1. Define a Property: Inherit from rfk::Property. Use CLASS(rfk::PropertySettings(...)) to specify which entity kinds (e.g., Struct, Class) this property can be attached to.
2. Attach the Property: Use the property name as a macro argument in the CLASS() macro of the target entity.
3. Read the Property: Use classArchetype->getPropertyByName("PropertyName") or classArchetype->getProperty<PropertyType>() to retrieve the metadata at runtime.

// 1. Define the property
class CLASS(rfk::PropertySettings(rfk::EEntityKind::Struct | rfk::EEntityKind::Class))
    ExampleProperty : public rfk::Property
{
    public:
    int someData;
    ExampleProperty(int data): someData{data} {}
    ExampleProperty_GENERATED
};

// 2. Attach it to a class
class CLASS(ExampleProperty(42)) TestClass3
{
    TestClass3_GENERATED
};

// 3. Read it
rfk::Class const* c = rfk::getDatabase().getFileLevelClassByName("TestClass3");
rfk::Property const* prop = c->getPropertyByName("ExampleProperty");

To reflect a class, you must use the generated header files and specific macros. The library is designed so that you write the reflection markers once, and the code generator handles the rest.

1. Include the generated header (e.g., "Generated/ClassName.rfkh.h").
2. Use the CLASS() macro on your class definition.
3. Use FIELD() or METHOD() macros on members you wish to reflect.
4. Include the generated source header (e.g., "Generated/ClassName.rfks.h") in one of your project's source files.
5. Add the ClassName_GENERATED macro inside the class and the File_ClassName_GENERATED marker in a source file to trigger registration.

//TestClass.h
#pragma once

#include "Generated/TestClass.rfkh.h"

class CLASS() TestClass
{
    FIELD()
    int _intField;

    METHOD()
    void testMethod();

    TestClass_GENERATED
};

File_TestClass_GENERATED

//TestClass.cpp
#include "Generated/TestClass.rfks.h"

The Refureku generator runs in two distinct phases to handle internal and public metadata:

1. Internal Generation: Runs runForInternalDirectory, which generates metadata into the Include/Internal/Refureku/Generated directory. This includes both header (.rfkh.h) and source (.rfks.h) files.
2. Public Generation: Runs runForPublicDirectory, which generates metadata into the Include/Public/Refureku/Generated directory. To keep the public API clean, it automatically deletes all generated source files (.rfks.h) from this directory after the process completes, leaving only the headers.

The generator uses rfk::ReflectionCodeGenModule to drive the actual reflection logic during the kodgen execution.

// Typical execution flow in main()
rfk::FileParser fileParser;
// ... setup logger and manager ...

rfk::ReflectionCodeGenModule reflectionCodeGenModule;
codeGenUnit.addModule(reflectionCodeGenModule);

runForInternalDirectory(logger, codeGenMgr, fileParser, codeGenUnit, codeGenUnitSettings);
runForPublicDirectory(logger, codeGenMgr, fileParser, codeGenUnit, codeGenUnitSettings);

Reflected classes can be instantiated even without direct access to their static type:

• Default Constructor: Use classArchetype->makeSharedInstance<T>() to create a rfk::SharedPtr<T>.
• Base Class Instantiation: You can instantiate a class and store it in a pointer to its base class.
• Custom Instantiation: If you need a custom constructor or a custom deleter, you can define a static method marked with METHOD(rfk::Instantiator) in your class. This method will be called when using makeSharedInstance with arguments.

// Instantiate from default ctor
rfk::Class const* c = rfk::getDatabase().getFileLevelClassByName("TestClass");
rfk::SharedPtr<TestClass> instance = c->makeSharedInstance<TestClass>();

// If TestClass has a base class, we can do
rfk::SharedPtr<BaseClass> instance2 = c->makeSharedInstance<BaseClass>();

// Custom Instantiator Example class CLASS() TestClass2 : public BaseClass { METHOD(rfk::Instantiator) static rfk::SharedPtr<TestClass2> customInstantiator(int i) { return rfk::SharedPtr<TestClass2>(new TestClass2(), [](TestClass2* ptr) { delete ptr; }); }

TestClass2_GENERATED

};

// Usage rfk::Class const* c2 = rfk::getDatabase().getFileLevelClassByName("TestClass2"); rfk::SharedPtr<BaseClass> instance3 = c2->makeSharedInstance<BaseClass>(42);

The loadSettings function configures the kodgen components used to generate reflection metadata for the Refureku library. It sets up file extensions, directory paths, naming patterns for generated files, and macro names used for property parsing.

Key configuration details include:

• Supported Extensions: .h, .hpp
• Generated File Patterns:
  • Header: ##FILENAME##.rfkh.h
  • Source: ##FILENAME##.rfks.h
• Macro Patterns:
  • Class Footer: ##CLASSFULLNAME##_GENERATED
  • Header Footer: File_##FILENAME##_GENERATED
  • Export Symbol: REFUREKU_API
• Property Parsing Macros:
  • RFKNamespace, RFKClass, RFKStruct, RFKVariable, RFKField, RFKFunction, RFKMethod, RFKEnum, RFKEnumVal
• Compiler: Uses clang++ with C++17.

bool loadSettings(kodgen::CodeGenManagerSettings& codeGenMgrSettings, kodgen::ParsingSettings& parsingSettings,
                 kodgen::MacroCodeGenUnitSettings& codeGenUnitSettings, fs::path outputDirectory)