ghassanpl/reflector

A small tool to create reflection information for C++ projects, ala Unreal's UHT

reflector's Issues

Split the code into better files

Right now a lot of the .h and .cpp files in the project have a lot of shared stuff in it, we need to break them up into smaller files with fewer responsibilities.

A good set of examples for the README and wiki

I would love to have some good examples of what Reflector is and what it allows users to do

Better use of icons in generated documentation

Right now we have icons for types and some docnotes. We could definitely have more for docnotes and such.

Figure out what limitations we can/should place on reflectable classes (deriving from Reflectable) and structs

Add `FullCompileTimeReflection` option

If true, will generate static constexpr methods, in the bodies of classes, for each reflected member

Maybe instead we should have an option like GeneratedReflectionData=Minimal | Normal | Full

More annotation types

This is a general issue that describes ideas for new annotation types

• RConstructor() ?
• RAlias()/RUsing(); - for commenting using X = ...; declarations, so that generated documentation is better (probably other things too)
• RConstant(); - for constexprs
• ROperator();
• RNamespace() ?
• RTest() ? - for marking static methods as tests
• RVersion() ? - or should we get that information from, in order: git tags, git commit, datetime
• RContext() ?
• RDoc();
• RCategory(Name, ...attributes); - for grouping together class members; attributes like Order = Declaration/Alphabetic or Order = {Documentation = Alphabetic, Editor = Declaration }, Collapsed = true; stuff like Document applies to all members, etc.

The schema for `ReflectDatabase.json` needs to be written down

This should also make sure we're writing all the reflection data to that file.

Finish `FindTypeByPossiblyQualifiedName` and `FindClassByPossiblyQualifiedName`

That part of the codebase needs proper heuristics to figure out if we're actually deriving from Reflectable.

Unify and simplify error reporting

It's a mess right now

Change `Reflectable::mClass` to `uint32_t mClassIndex;`

This will reduce the size of Reflectable from 24 to 16 bytes, which is not a lot but adds up across the codebase for something that is a base class for stuff.

Make sure class attributes are inherited (or not) by child classes, as appropriate

It would be cool if we could specify propagation (NoPropagate, OnlyDirectlyDeriving, AllDerived) in the attribute definition, and handle it automatically in the database building

Custom attributes

It would be great to have user-definable attributes, perhaps even with behaviors attached to them.

Something like C# attributes.

Support for at least one or two types of schema generation

Like:

• JSON schema
• protobuf files
• SQL CREATE TABLE

plus generation of code that loads and stores these formats

Make `Heap` multithreading-safe

More generated documentation pages

Specifically:

• some sort of home/landing/splash page
• pages for namespaces
• generate pages for attributes linked in the documentation

Figure out BaseResolvable

The class right now probably doesn't work, and if it does, it probably doesn't belong in that header

Decide if we should call the `OnChange` code when a field is deserialized

Also check other places where we potentially change field values (like FieldReflectionData setters)

Ability to deep clone GC-enabled objects

Proper testing

This project needs proper testing:

• all options and option combinations
• all attributes and attribute combinations
• which field/parameter/return types don't work
• and more

Make sure we're ensuring field `CleanName`s are unique

The database needs to check if, when CleanName attributes are specified, that all those names are unique within parent type.

Bring back script binding support

But make it good, and not only for Lua

Document the *.h artifacts

Headers like ReflectorClasses.h need proper documentation of the types inside.

Make GC-enabled classes able to be proper singletons

This would mean that New() would always return the same value, only one instance can be constructed, and SingletonGet() always returns a valid pointer.

More configurable documentation

Specifically, two issues:

1. The ability to change the output format, or use multiple output formats, like .md
2. The ability to change the programming language the documentation uses to display types, namespace, and code (e.g. if we want to output documentation only for scriptable entities), or output separate documentation for scripting

Rename `ClassReflectionData` to just `Class`

Support disabling annotations in #if/#endif blocks

Currently, reflector does not respect #if/#endif blocks and will treat annotations inside them as valid. This should be fixed with a high priority, but needs to be able to handle macros and such, and that's a massive pain.

How does doxygen do it?