Class.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);

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

    template <typename ReturnType>
    ManagedClass &registerStaticMethod(const std::string &name, ReturnType(*method)());

    template <typename ReturnType, typename ClassType>
    ManagedClass &registerMethod(const std::string &name, ReturnType(ClassType::*method)());

    template <typename ReturnType, typename ClassType>
    ManagedClass &registerMethod(const std::string &name, ReturnType(ClassType::*method)() const);
    template <typename ClassType, typename A0>
    ManagedClass &registerConstructor(void);

    template <typename A0, typename ReturnType>
    ManagedClass &registerStaticMethod(const std::string &name, ReturnType(*method)(A0));

    template <typename A0, typename ReturnType, typename ClassType>
    ManagedClass &registerMethod(const std::string &name, ReturnType(ClassType::*method)(A0));

    template <typename A0, typename ReturnType, typename ClassType>
    ManagedClass &registerMethod(const std::string &name, ReturnType(ClassType::*method)(A0) const);
    template <typename ClassType, typename A0, typename A1>
    ManagedClass &registerConstructor(void);

    template <typename A0, typename A1, typename ReturnType>
    ManagedClass &registerStaticMethod(const std::string &name, ReturnType(*method)(A0, A1));

    template <typename A0, typename A1, typename ReturnType, typename ClassType>
    ManagedClass &registerMethod(const std::string &name, ReturnType(ClassType::*method)(A0, A1));

    template <typename A0, typename A1, typename ReturnType, typename ClassType>
    ManagedClass &registerMethod(const std::string &name, ReturnType(ClassType::*method)(A0, A1) const);
    template <typename ClassType, typename A0, typename A1, typename A2>
    ManagedClass &registerConstructor(void);

    template <typename A0, typename A1, typename A2, typename ReturnType>
    ManagedClass &registerStaticMethod(const std::string &name, ReturnType(*method)(A0, A1, A2));

    template <typename A0, typename A1, typename A2, typename ReturnType, typename ClassType>
    ManagedClass &registerMethod(const std::string &name, ReturnType(ClassType::*method)(A0, A1, A2));

    template <typename A0, typename A1, typename A2, typename ReturnType, typename ClassType>
    ManagedClass &registerMethod(const std::string &name, ReturnType(ClassType::*method)(A0, A1, A2) const);
    template <typename ClassType, typename A0, typename A1, typename A2, typename A3>
    ManagedClass &registerConstructor(void);

    template <typename A0, typename A1, typename A2, typename A3, typename ReturnType>
    ManagedClass &registerStaticMethod(const std::string &name, ReturnType(*method)(A0, A1, A2, A3));

    template <typename A0, typename A1, typename A2, typename A3, typename ReturnType, typename ClassType>
    ManagedClass &registerMethod(const std::string &name, ReturnType(ClassType::*method)(A0, A1, A2, A3));

    template <typename A0, typename A1, typename A2, typename A3, typename ReturnType, typename ClassType>
    ManagedClass &registerMethod(const std::string &name, ReturnType(ClassType::*method)(A0, A1, A2, A3) const);
    template <typename ClassType, typename A0, typename A1, typename A2, typename A3, typename A4>
    ManagedClass &registerConstructor(void);

    template <typename A0, typename A1, typename A2, typename A3, typename A4, typename ReturnType>
    ManagedClass &registerStaticMethod(const std::string &name, ReturnType(*method)(A0, A1, A2, A3, A4));

    template <typename A0, typename A1, typename A2, typename A3, typename A4, typename ReturnType, typename ClassType>
    ManagedClass &registerMethod(const std::string &name, ReturnType(ClassType::*method)(A0, A1, A2, A3, A4));

    template <typename A0, typename A1, typename A2, typename A3, typename A4, typename ReturnType, typename ClassType>
    ManagedClass &registerMethod(const std::string &name, ReturnType(ClassType::*method)(A0, A1, A2, A3, A4) const);
    template <typename ClassType, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5>
    ManagedClass &registerConstructor(void);

    template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename ReturnType>
    ManagedClass &registerStaticMethod(const std::string &name, ReturnType(*method)(A0, A1, A2, A3, A4, A5));

    template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename ReturnType, typename ClassType>
    ManagedClass &registerMethod(const std::string &name, ReturnType(ClassType::*method)(A0, A1, A2, A3, A4, A5));

    template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename ReturnType, typename ClassType>
    ManagedClass &registerMethod(const std::string &name, ReturnType(ClassType::*method)(A0, A1, A2, A3, A4, A5) const);
    template <typename ClassType, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6>
    ManagedClass &registerConstructor(void);

    template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename ReturnType>
    ManagedClass &registerStaticMethod(const std::string &name, ReturnType(*method)(A0, A1, A2, A3, A4, A5, A6));

    template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename ReturnType, typename ClassType>
    ManagedClass &registerMethod(const std::string &name, ReturnType(ClassType::*method)(A0, A1, A2, A3, A4, A5, A6));

    template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename ReturnType, typename ClassType>
    ManagedClass &registerMethod(const std::string &name, ReturnType(ClassType::*method)(A0, A1, A2, A3, A4, A5, A6) const);
    template <typename ClassType, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7>
    ManagedClass &registerConstructor(void);

    template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename ReturnType>
    ManagedClass &registerStaticMethod(const std::string &name, ReturnType(*method)(A0, A1, A2, A3, A4, A5, A6, A7));

    template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename ReturnType, typename ClassType>
    ManagedClass &registerMethod(const std::string &name, ReturnType(ClassType::*method)(A0, A1, A2, A3, A4, A5, A6, A7));

    template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename ReturnType, typename ClassType>
    ManagedClass &registerMethod(const std::string &name, ReturnType(ClassType::*method)(A0, A1, A2, A3, A4, A5, A6, A7) const);
    template <typename ClassType, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8>
    ManagedClass &registerConstructor(void);

    template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename ReturnType>
    ManagedClass &registerStaticMethod(const std::string &name, ReturnType(*method)(A0, A1, A2, A3, A4, A5, A6, A7, A8));

    template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename ReturnType, typename ClassType>
    ManagedClass &registerMethod(const std::string &name, ReturnType(ClassType::*method)(A0, A1, A2, A3, A4, A5, A6, A7, A8));

    template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename ReturnType, typename ClassType>
    ManagedClass &registerMethod(const std::string &name, ReturnType(ClassType::*method)(A0, A1, A2, A3, A4, A5, A6, A7, A8) const);

    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