dispatch.h

Go to the documentation of this file.

 
#ifndef INCLUDE_MEXPLUS_DISPATCH_H_
#define INCLUDE_MEXPLUS_DISPATCH_H_
 
#include <mex.h>
#include <map>
#include <memory>
#include <string>
 
#ifndef MEXPLUS_AT_EXIT
#define MEXPLUS_AT_EXIT
#endif
 
#ifndef MEXPLUS_AT_INIT
#define MEXPLUS_AT_INIT
#endif
 
#ifndef MEXPLUS_AT_ERROR
#define MEXPLUS_AT_ERROR(name)
#endif
 
namespace mexplus {
 
typedef bool OperationNameAdmitter(const std::string& name);
 
class OperationCreator;
inline void CreateOperation(OperationNameAdmitter* admitter,
                            OperationCreator* creator);
 
class Operation {
 public:
  virtual ~Operation() {}
  virtual void operator()(int nlhs,
                          mxArray *plhs[],
                          int nrhs,
                          const mxArray *prhs[]) = 0;
};
 
class OperationCreator {
 public:
  explicit OperationCreator(OperationNameAdmitter* admitter) {
    CreateOperation(admitter, this);
  }
  virtual ~OperationCreator() {}
  virtual Operation* create() = 0;
};
 
template <class OperationClass>
class OperationCreatorImpl : public OperationCreator {
 public:
  explicit OperationCreatorImpl(OperationNameAdmitter* admitter,
                                const char* tag) :
      OperationCreator(admitter) {
    if (tag)
      mexPrintf("Tag: %s\n", tag);
  }
  virtual Operation* create() { return new OperationClass; }
};
 
class OperationFactory {
 public:
  typedef std::map<OperationNameAdmitter*, OperationCreator*> RegistryMap;
 
  friend void CreateOperation(OperationNameAdmitter* admitter,
                              OperationCreator* creator);
  static Operation* create(const std::string& name) {
    RegistryMap::const_iterator it = find(name);
    return (it == registry()->end()) ?
      static_cast<Operation*>(NULL) : it->second->create();
  }
  static RegistryMap* registry() {
    static RegistryMap registry_table;
    return &registry_table;
  }
 
 private:
  static RegistryMap::const_iterator find(const std::string& name) {
    RegistryMap::const_iterator it;
    for (it = registry()->begin(); it != registry()->end(); it++) {
      if ((*it->first)(name))
        return it;
    }
    return it;
  }
};
 
inline void CreateOperation(OperationNameAdmitter* admitter,
                            OperationCreator* creator) {
  OperationFactory::registry()->insert(std::make_pair(admitter, creator));
}
 
template<class T>
class Session {
 public:
  typedef std::map<intptr_t, std::shared_ptr<T> > InstanceMap;
 
  static intptr_t create(T* instance) {
    InstanceMap* instances = getInstances();
    intptr_t id = reinterpret_cast<intptr_t>(instance);
    instances->insert(std::make_pair(id, std::shared_ptr<T>(instance)));
    mexLock();
    return id;
  }
  static void destroy(intptr_t id) {
    getInstances()->erase(id);
    mexUnlock();
  }
  static void destroy(const mxArray* pointer) {
    destroy(getIntPointer(pointer));
  }
  static T* get(intptr_t id) {
    InstanceMap* instances = getInstances();
    typename InstanceMap::iterator instance = instances->find(id);
    if (instance == instances->end())
      mexErrMsgIdAndTxt("mexplus:session:notFound",
                        "Invalid id %d. Did you create?",
                        id);
    return instance->second.get();
  }
  static T* get(const mxArray* pointer) {
    return get(getIntPointer(pointer));
  }
  static const T& getConst(intptr_t id) {
    return *get(id);
  }
  static const T& getConst(const mxArray* pointer) {
    return getConst(getIntPointer(pointer));
  }
  static bool exist(intptr_t id) {
    InstanceMap* instances = getInstances();
    typename InstanceMap::iterator instance = instances->find(id);
    return instance != instances->end();
  }
  static bool exist(const mxArray* pointer) {
    return exist(getIntPointer(pointer));
  }
  static void clear() {
    for (int i = 0; i < getInstances()->size(); ++i)
      mexUnlock();
    getInstances()->clear();
  }
  static const InstanceMap& getInstanceMap() { return *getInstances(); }
 
 private:
  Session() {}
  ~Session() {}
  static intptr_t getIntPointer(const mxArray* pointer) {
    if (mxIsEmpty(pointer))
      mexErrMsgIdAndTxt("mexplus:session:invalidType", "Id is empty.");
    if (sizeof(intptr_t) == 8 && !mxIsInt64(pointer) && !mxIsUint64(pointer))
      mexErrMsgIdAndTxt("mexplus:session:invalidType",
                        "Invalid id type %s.",
                        mxGetClassName(pointer));
    if (sizeof(intptr_t) == 4 && !mxIsInt32(pointer) && !mxIsUint32(pointer))
      mexErrMsgIdAndTxt("mexplus:session:invalidType",
                        "Invalid id type %s.",
                        mxGetClassName(pointer));
    return *reinterpret_cast<intptr_t*>(mxGetData(pointer));
  }
  static InstanceMap* getInstances() {
    static InstanceMap instances;
    return &instances;
  }
};
 
}  // namespace mexplus
 
#define MEX_DEFINE(name) \
class Operation_##name : public mexplus::Operation { \
 public: \
  virtual void operator()(int nlhs, \
                          mxArray *plhs[], \
                          int nrhs, \
                          const mxArray *prhs[]); \
 private: \
  static bool Operation_Admitter(const std::string& func) { \
    return func == #name;\
  } \
  static const mexplus::OperationCreatorImpl<Operation_##name> creator_; \
}; \
const mexplus::OperationCreatorImpl<Operation_##name> \
    Operation_##name::creator_(Operation_##name::Operation_Admitter, NULL); \
void Operation_##name::operator()
 
#define MEX_DEFINE2(name, admitter) \
static const char* tag = NULL /*#name*/; \
class Operation_##name : public mexplus::Operation { \
 public: \
  virtual void operator()(int nlhs, \
                          mxArray *plhs[], \
                          int nrhs, \
                          const mxArray *prhs[]); \
 private: \
  static const mexplus::OperationCreatorImpl<Operation_##name> creator_; \
}; \
const mexplus::OperationCreatorImpl<Operation_##name> \
    Operation_##name::creator_(admitter, tag); \
void Operation_##name::operator()
 
#define MEX_DISPATCH \
void mexFunction(int nlhs, mxArray *plhs[], \
                 int nrhs, const mxArray *prhs[]) { \
  MEXPLUS_AT_INIT;\
  if (nrhs < 1 || !mxIsChar(prhs[0])) \
    mexErrMsgIdAndTxt("mexplus:dispatch:argumentError", \
                      "Invalid argument: missing operation."); \
  std::string operation_name(\
      mxGetChars(prhs[0]), \
      mxGetChars(prhs[0]) + mxGetNumberOfElements(prhs[0])); \
  std::unique_ptr<mexplus::Operation> operation(\
      mexplus::OperationFactory::create(operation_name)); \
  if (operation.get() == NULL) { \
    MEXPLUS_AT_ERROR(operation_name); \
    mexErrMsgIdAndTxt("mexplus:dispatch:argumentError", \
        "Invalid operation: %s", operation_name.c_str()); \
  } \
  (*operation)(nlhs, plhs, nrhs - 1, prhs + 1); \
  MEXPLUS_AT_EXIT; \
}
 
#endif  // INCLUDE_MEXPLUS_DISPATCH_H_