almethodinfo.h

Go to the documentation of this file.

#pragma once
#ifndef _LIBALCOMMON_ALCOMMON_ALMETHODINFO_H_
#define _LIBALCOMMON_ALCOMMON_ALMETHODINFO_H_

# include <alcommon/api.h>
# include <boost/shared_ptr.hpp>


# define BLOCKINGFUNCTION     0 
# define ASYNCHRONOUSFUNCTION 1 
namespace AL
{
  class ALFunctorBase;

  class ALMethodInfo
  {
  public:
    ALMethodInfo() {
      mask = 0;
    }

    virtual ~ALMethodInfo() {}

    enum methodOption {
      CPPMethod           = 1, 
      AsynchronousMethod  = 2, 
      localMethod         = 4  
    };

    class ALParameterInfo
    {
    public:
      std::string paramError;  
      std::string name;        
      std::string description; 
      std::string strType;     
      bool        optional;    
    };

    template <typename T>
    class ALParameterInfoOptional: public ALParameterInfo {
    public:
      ALParameterInfoOptional(T defaultValue) {
        m_defaultValue = defaultValue;
      }
      T m_defaultValue; 
    };

    class ALExample {
    public:
      std::string language;   
      std::string strExample; 
    };

    std::string                      moduleName;        
    std::string                      methodName;        
    std::string                      methodDescription; 
    std::vector<ALParameterInfo>     parameters;        
    std::string                      returnValue;       
    std::vector<ALExample>           examples;          
    boost::shared_ptr<ALFunctorBase> ptrOnMethod;       
    ALParameterInfo                  returnInfo;        
    short                            mask;              
    bool isCpp(void) {
      return ((mask & CPPMethod) == CPPMethod);
    }

    bool isAsynchronous(void) {
      return (mask & AsynchronousMethod) > 0 ? true: false;
    }

    bool isLocalMethod(void) {
      return ((mask & localMethod) == localMethod);
    }

    void addOption(int pOption)
    {
      mask = mask | (short)pOption;
    }

    ALFunctorBase* getFunction() {
      return ptrOnMethod.get();
    }

    void clear(void) {
      parameters.clear();
      examples.clear();
    }
  };

  template <typename C, typename R>
  void completeAndCheck(R(C::*) (), ALMethodInfo & pDesc)
  {
    //useless
  }

  template <typename C, typename P1, typename R>
  void completeAndCheck(R(C::*) (P1), ALMethodInfo & pDesc)
  {
    //useless
  }

  template <typename C, typename P1, typename P2, typename R>
  void completeAndCheck(R(C::*) (P1, P2), ALMethodInfo & pDesc)
  {
    //useless
  }

  template <typename C, typename P1, typename P2, typename P3, typename R>
  void completeAndCheck(R(C::*) (P1, P2, P3), ALMethodInfo & pDesc)
  {
    //useless
  }

  template <typename C, typename P1, typename P2, typename P3, typename P4, typename R>
  void completeAndCheck(R(C::*) (P1, P2, P3, P4), ALMethodInfo & pDesc)
  {
    //useless
  }

  template <typename C, typename P1, typename P2, typename P3, typename P4, typename P5, typename R>
  void completeAndCheck(R(C::*) (P1, P2, P3, P4, P5), ALMethodInfo & pDesc)
  {
    //useless
  }

  template <typename C, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename R>
  void completeAndCheck(R(C::*) (P1, P2, P3, P4, P5, P6), ALMethodInfo & pDesc)
  {
    //useless
  }

}
#endif  // _LIBALCOMMON_ALCOMMON_ALMETHODINFO_H_