boost::openmethod::register_classes

Declared in <boost/openmethod/core.hpp>

register_classes is a registrar class that finds the classes taking part in dispatch by reflection, and adds them to one or more registries. It makes use_classes unnecessary in most cases.

The arguments are groups of reflections, each written in braces ‐ or, for a group of one, as the reflection itself. A group holds one kind of reflection, and the groups come in this order; each one is optional, and omitting all of them is the common case:

A group holding two kinds of reflection is an error, and so is a group out of order. Braces around a single reflection change nothing: register_classes<ˆˆapp> and register_classes<{ˆˆapp}> are the same registration.

The scan covers the listed namespaces, the namespaces nested in them, and the classes nested in the classes it declares, except std and boost: walking those would cost a great deal and find nothing, as a method cannot be declared on a class the program has never heard of. The exclusion applies to recursion only, so a class in std or boost is registered by listing the namespace it is in. The scan never goes through an alias: a namespace alias is not entered, and a type alias registers the class it names but is not walked into. The scan finds the methods of each target registry and collects the classes they dispatch on; those, and the listed classes, are the roots. It registers the roots, and every class it finds that derives from one of them. A base class that no method dispatches on, and that is not listed, is not registered: it could never be selected on.

A class between a registered class and a root is registered too, wherever it is declared: in a namespace the scan does not enter, or as a specialization of a class template, which the scan cannot find on its own. The namespaces decide where the derived classes are looked for, not which bases are recorded; and each class is recorded with every registered class above it, so that a registration stands on its own, whatever another one, in another translation unit, registers alongside it.

If no namespace is given, the global namespace is scanned ‐ whatever the other groups hold, and for BOOST_OPENMETHOD_REGISTER_CLASSES too. Name a namespace to scan only that one.

The scan runs when the registrar is instantiated, which current compilers do at the end of the translation unit: it sees the whole file, wherever the registrar sits. The standard promises less. A class or a method the scan would select, declared after the registrar in the same translation unit, makes the program ill‐formed, no diagnostic required. Put the registrar after the declarations it is meant to find, at the bottom of the file.

A method is found through any namespace member that names its method specialization: the alias BOOST_OPENMETHOD declares for it, a using declaration written by hand, or any of its registrar objects ‐ the object BOOST_OPENMETHOD_OVERRIDE creates, or one written by hand. None of those requires the method to have an overrider. A core interface method whose method<...> type is spelled out in full at every use, with neither a using declaration nor an overrider, is named by nothing and is not found; its classes must be registered with use_classes. A method's return type is not a root: a covariant return type is registered like any other class, when it derives from a root, or when it is listed.

Virtual and multiple inheritance are supported. Unlike use_classes, which rejects it, repeated inheritance is not an error here: a class is recorded under the bases it reaches unambiguously through public inheritance, and a base it inherits more than once, which no reference to it can be converted to, is left out of its list. A class with no registered class above it is not registered at all.

Core API

Created with MrDocs