Class.tmpl.hpp

Go to the documentation of this file.

#pragma once
#include <Pothos/Config.hpp>
#include <Pothos/Callable/Callable.hpp>
#include <string>
#include <memory>
#include <typeinfo>

namespace Pothos {

class POTHOS_API ManagedClass
{
public:

    static ManagedClass lookup(const std::type_info &type);

    ManagedClass(void);

    template <typename ClassType>
    ManagedClass &registerClass(void);

    template <typename ClassType, typename BaseClassType>
    ManagedClass &registerBaseClass(void);

    ManagedClass &registerToBaseClass(const Callable &toBase);

    #for $NARGS in range($MAX_ARGS)

    template <typename ClassType, $expand('typename A%d', $NARGS)>
    ManagedClass &registerConstructor(void);

    template <$expand('typename A%d', $NARGS), typename ReturnType>
    ManagedClass &registerStaticMethod(const std::string &name, ReturnType(*method)($expand('A%d', $NARGS)));

    template <$expand('typename A%d', $NARGS), typename ReturnType, typename ClassType>
    ManagedClass &registerMethod(const std::string &name, ReturnType(ClassType::*method)($expand('A%d', $NARGS)));

    template <$expand('typename A%d', $NARGS), typename ReturnType, typename ClassType>
    ManagedClass &registerMethod(const std::string &name, ReturnType(ClassType::*method)($expand('A%d', $NARGS)) const);
    #end for

    template <typename ClassType, typename ValueType>
    ManagedClass &registerField(const std::string &name, ValueType ClassType::*member);

    ManagedClass &registerReferenceToWrapper(const Callable &toPointer);

    ManagedClass &registerPointerToWrapper(const Callable &toPointer);

    ManagedClass &registerSharedToWrapper(const Callable &toPointer);

    ManagedClass &registerConstructor(const Callable &constructor);

    ManagedClass &registerStaticMethod(const std::string &name, const Callable &method);

    ManagedClass &registerMethod(const std::string &name, const Callable &method);

    ManagedClass &registerOpaqueConstructor(const Callable &constructor);

    template <typename ClassType>
    ManagedClass &registerOpaqueConstructor(void);

    ManagedClass &registerOpaqueStaticMethod(const std::string &name, const Callable &method);

    ManagedClass &registerWildcardStaticMethod(const Callable &method);

    ManagedClass &registerOpaqueMethod(const std::string &name, const Callable &method);

    ManagedClass &registerWildcardMethod(const Callable &method);

    ManagedClass &commit(const std::string &classPath);

    static void unload(const std::string &classPath);

    const std::type_info &type(void) const;

    const std::type_info &pointerType(void) const;

    const std::type_info &sharedType(void) const;

    const Callable &getReferenceToWrapper(void) const;

    const Callable &getPointerToWrapper(void) const;

    const Callable &getSharedToWrapper(void) const;

    const std::vector<Callable> &getBaseClassConverters(void) const;

    const std::vector<Callable> &getConstructors(void) const;

    const std::vector<Callable> &getStaticMethods(const std::string &name) const;

    const std::vector<Callable> &getMethods(const std::string &name) const;

    const Callable &getOpaqueConstructor(void) const;

    const Callable &getOpaqueStaticMethod(const std::string &name) const;

    const Callable &getWildcardStaticMethod(void) const;

    const Callable &getOpaqueMethod(const std::string &name) const;

    const Callable &getWildcardMethod(void) const;

private:
    struct Impl;
    std::shared_ptr<Impl> _impl;
};

} //namespace Pothos