derivedtobaseadaptor.h File Reference

#include "Workspace/Application/LanguageUtils/classconstraints.h"
#include "Workspace/Application/LanguageUtils/errorchecks.h"
#include "Workspace/api_workspace.h"
#include "datafactorytraits.h"
#include "dataobject.h"
#include "typeadaptor.h"
#include "typeadaptorfactory.h"
#include "typeddatafactory.h"

Include dependency graph for derivedtobaseadaptor.h:

This graph shows which files directly or indirectly include this file:

Classes
class	DerivedToBaseAdaptor< D, B >
	A TypeAdaptor class for converting a derived class to a base class. More...
class	DerivedToBaseAdaptorFactory< D, B >
	A TypeAdaptorFactory class for an adaptor converting a derived class to a base class. More...

Namespaces
namespace	CSIRO
	Top level namespace for all Workspace code.
namespace	CSIRO::DataExecution
	Base workspace functionality not requiring a user interface.

Macros
#define	DECLARE_WORKSPACE_DERIVEDTOBASEADAPTOR(D, B, WORKSPACE_EXPORT_SYMBOL)
#define	DEFINE_WORKSPACE_DERIVEDTOBASEADAPTOR(D, B, P)

Macro Definition Documentation

DECLARE_WORKSPACE_DERIVEDTOBASEADAPTOR

#define DECLARE_WORKSPACE_DERIVEDTOBASEADAPTOR	(		D,
			B,
			WORKSPACE_EXPORT_SYMBOL
	)

Value:

    namespace CSIRO                                                                                                    \
    {                                                                                                                  \
    namespace DataExecution                                                                                            \
    {                                                                                                                  \
    template<>                                                                                                         \
    WORKSPACE_EXPORT_SYMBOL const DerivedToBaseAdaptorFactory<D, B>& DerivedToBaseAdaptorFactory<D, B>::getInstance(); \
    template<>                                                                                                         \
    WORKSPACE_EXPORT_SYMBOL                                                                                            \
        TypeAdaptor*                                                                                                   \
        DerivedToBaseAdaptorFactory<D, B>::create() const;                                                             \
    template<>                                                                                                         \
    WORKSPACE_EXPORT_SYMBOL void DerivedToBaseAdaptorFactory<D, B>::destroy(TypeAdaptor* a) const;                     \
    template<>                                                                                                         \
    WORKSPACE_EXPORT_SYMBOL const Application::WorkspacePlugin& DerivedToBaseAdaptorFactory<D, B>::getPlugin() const;  \
    }                                                                                                                  \
    }

This macro is analogous to the DECLARE_WORKSPACE_DATA_FACTORY macro. See its detailed description for why we also need a similar macro for derived to base adaptor factories.

DEFINE_WORKSPACE_DERIVEDTOBASEADAPTOR

#define DEFINE_WORKSPACE_DERIVEDTOBASEADAPTOR	(		D,
			B,
			P
	)

Value:

    namespace CSIRO                                                                                            \
    {                                                                                                          \
    namespace DataExecution                                                                                    \
    {                                                                                                          \
    template<>                                                                                                 \
    CSIRO_EXPORTSPEC                                                                                           \
        TypeAdaptor*                                                                                           \
        DerivedToBaseAdaptorFactory<D, B>::create() const                                                      \
    {                                                                                                          \
        return new DerivedToBaseAdaptor<D, B>;                                                                 \
    }                                                                                                          \
    template<>                                                                                                 \
    CSIRO_EXPORTSPEC void DerivedToBaseAdaptorFactory<D, B>::destroy(TypeAdaptor* adaptor) const               \
    {                                                                                                          \
        delete adaptor;                                                                                        \
    }                                                                                                          \
    template<>                                                                                                 \
    CSIRO_EXPORTSPEC const DerivedToBaseAdaptorFactory<D, B>& DerivedToBaseAdaptorFactory<D, B>::getInstance() \
    {                                                                                                          \
        static DerivedToBaseAdaptorFactory<D, B> instance;                                                     \
        return instance;                                                                                       \
    }                                                                                                          \
    template<>                                                                                                 \
    CSIRO_EXPORTSPEC const Application::WorkspacePlugin& DerivedToBaseAdaptorFactory<D, B>::getPlugin() const  \
    {                                                                                                          \
        return P;                                                                                              \
    }                                                                                                          \
    template class DerivedToBaseAdaptor<D, B>;                                                                 \
    }                                                                                                          \
    }

Parameters

D	The type of the derived class.
B	The type of the base class.
P	A reference to the plugin that provides the adaptor.

A macro for explicitly instantiating a DerivedToBaseAdaptor and its factory. The use of this macro is the preferred method of instantiating such an adaptor and its factory for a particular type. It should only ever be used in an implementation file and never in a header file. It would normally be used in the file that implements the type D, typically at the end of that file.