NativeClassInterface.h

00001 // NativeClassInterface.h 2013/3/13
00002 #pragma once
00003 #include <stdarg.h>
00004 class NativeClassInterface {
00005 public:
00006     template<class T>
00007     PmReturn_t init()
00008     {
00009         PmReturn_t retval = check_argv_type(0);
00010         PM_RETURN_IF_ERROR(retval);
00011         T* obj = new T();
00012         return _save_obj<T>(obj);
00013     }
00014 
00015     template<class T, typename A1>
00016     PmReturn_t init(PmType_t a1_type)
00017     {
00018         PmReturn_t retval = check_argv_type(1, a1_type);
00019         PM_RETURN_IF_ERROR(retval);
00020         T* obj = new T(argv<A1>(1));
00021         return _save_obj<T>(obj);
00022     }
00023 
00024     template<class T, typename A1, typename A2>
00025     PmReturn_t init(PmType_t a1_type, PmType_t a2_type)
00026     {
00027         PmReturn_t retval = check_argv_type(2, a1_type, a2_type);
00028         PM_RETURN_IF_ERROR(retval);
00029         T* obj = new T(argv<A1>(1), argv<A2>(2));
00030         return _save_obj<T>(obj);
00031     }
00032 
00033     template<class T, typename A1, typename A2, typename A3>
00034     PmReturn_t init(PmType_t a1_type, PmType_t a2_type, PmType_t a3_type)
00035     {
00036         PmReturn_t retval = check_argv_type(3, a1_type, a2_type, a3_type);
00037         PM_RETURN_IF_ERROR(retval);
00038         T* obj = new T(argv<A1>(1), argv<A2>(2), argv<A3>(3));
00039         return _save_obj<T>(obj);
00040     }
00041 
00042     template<class T, void(T::*member)()>
00043     PmReturn_t method(PmType_t ret_type)
00044     {
00045         PmReturn_t retval = check_argv_type(0);
00046         PM_RETURN_IF_ERROR(retval);
00047         T* obj;
00048         retval = _load_obj<T>(&obj);
00049         PM_RETURN_IF_ERROR(retval);
00050         (obj->*member)();
00051         NATIVE_SET_TOS(PM_NONE);
00052         return retval;
00053     }
00054 
00055     template<class T, typename A1, void(T::*member)(A1)>
00056     PmReturn_t method(PmType_t ret_type, PmType_t a1_type)
00057     {
00058         PmReturn_t retval = check_argv_type(1, a1_type);
00059         PM_RETURN_IF_ERROR(retval);
00060         T* obj;
00061         retval = _load_obj<T>(&obj);
00062         PM_RETURN_IF_ERROR(retval);
00063         (obj->*member)(argv<A1>(1));
00064         NATIVE_SET_TOS(PM_NONE);
00065         return retval;
00066     }
00067 
00068     template<class T, typename A1, typename A2, void(T::*member)(A1,A2)>
00069     PmReturn_t method(PmType_t ret_type, PmType_t a1_type, PmType_t a2_type)
00070     {
00071         PmReturn_t retval = check_argv_type(2, a1_type, a2_type);
00072         PM_RETURN_IF_ERROR(retval);
00073         T* obj;
00074         retval = _load_obj<T>(&obj);
00075         PM_RETURN_IF_ERROR(retval);
00076         (obj->*member)(argv<A1>(1), argv<A2>(2));
00077         NATIVE_SET_TOS(PM_NONE);
00078         return retval;
00079     }
00080 
00081     template<typename R, class T, R(T::*member)()>
00082     PmReturn_t method(PmType_t ret_type)
00083     {
00084         PmReturn_t retval = check_argv_type(0);
00085         PM_RETURN_IF_ERROR(retval);
00086         T* obj;
00087         retval = _load_obj<T>(&obj);
00088         PM_RETURN_IF_ERROR(retval);
00089         R value = (obj->*member)();
00090         return set_return_value<R>(ret_type, value);
00091     }
00092 
00093     template<typename R, class T, typename A1, R(T::*member)(A1)>
00094     PmReturn_t method(PmType_t ret_type, PmType_t a1_type)
00095     {
00096         PmReturn_t retval = check_argv_type(1, a1_type);
00097         PM_RETURN_IF_ERROR(retval);
00098         T* obj;
00099         retval = _load_obj<T>(&obj);
00100         PM_RETURN_IF_ERROR(retval);
00101         R value = (obj->*member)(argv<A1>(1));
00102         return set_return_value<R>(ret_type, value);
00103     }
00104 
00105     template<typename R, class T, typename A1, typename A2, typename A3, typename A4, R(T::*member)(A1, A2, A3, A4)>
00106     PmReturn_t method(PmType_t ret_type, PmType_t a1_type, PmType_t a2_type, PmType_t a3_type, PmType_t a4_type)
00107     {
00108         PmReturn_t retval = check_argv_type(4, a1_type, a2_type, a3_type, a4_type);
00109         PM_RETURN_IF_ERROR(retval);
00110         T* obj;
00111         retval = _load_obj<T>(&obj);
00112         PM_RETURN_IF_ERROR(retval);
00113         R value = (obj->*member)(argv<A1>(1), argv<A2>(2), argv<A3>(3), argv<A4>(4));
00114         return set_return_value<R>(ret_type, value);
00115     }
00116 
00117     PmReturn_t check_argv_type(int arg_n, ...);
00118     
00119     template<class T>
00120     PmReturn_t _save_obj(T* obj)
00121     {
00122         PmReturn_t retval = PM_RET_OK;
00123         pPmObj_t pself = NATIVE_GET_LOCAL(0);
00124         pPmObj_t pattrs = (pPmObj_t)((pPmInstance_t)pself)->cli_attrs;
00125         pPmObj_t pn;
00126         retval = int_new((uint32_t)obj, &pn);
00127         PM_RETURN_IF_ERROR(retval);
00128         uint8_t objid;
00129         heap_gcPushTempRoot(pn, &objid);
00130         retval = dict_setItem(pattrs, PM_NONE, pn);
00131         heap_gcPopTempRoot(objid);
00132         PM_RETURN_IF_ERROR(retval);
00133         NATIVE_SET_TOS(PM_NONE);
00134         return retval;
00135     }
00136 
00137     template<class T>
00138     PmReturn_t _load_obj(T** obj)
00139     {
00140         PmReturn_t retval = PM_RET_OK;
00141         pPmObj_t pself = NATIVE_GET_LOCAL(0);
00142         pPmObj_t pattrs = reinterpret_cast<pPmObj_t>(((pPmInstance_t)pself)->cli_attrs);
00143         pPmObj_t pn;
00144         retval = dict_getItem(pattrs, PM_NONE, &pn);
00145         PM_RETURN_IF_ERROR(retval);
00146         *obj = reinterpret_cast<T*>(((pPmInt_t)pn)->val);
00147         return retval;
00148     }
00149 
00150     template<typename R>
00151     PmReturn_t set_return_value(PmType_t ret_type, R value);
00152 
00153     template<typename A>
00154     A argv(int n);
00155 };