लुआ के लिए एक आवरण के उदाहरण का उपयोग करते हुए तर्कों की एक चर संख्या के साथ पैटर्न

मुझे Lua को C ++ प्रोजेक्ट में बांधना आवश्यक था। हाथ से रैपर लिखने के लिए बहुत आलसी (बहुत लिखने के लिए) है, तैयार-किए गए एक कारण या किसी अन्य के लिए फिट नहीं थे। मैंने खुद लिखने का फैसला किया। इसलिए मैंने सोचा कि इंटरफ़ेस को यथासंभव सरल कैसे बनाया जाए? इस विचार से, मेरे सिर पर चढ़ने वाले टेम्पलेट्स से भयानक डिजाइन। तो यह बाद में निकला, लेकिन जितना लग रहा था, उससे कहीं ज्यादा सरल था।

C ++ 11 में, तर्कों की एक चर संख्या के साथ टेम्प्लेट दिखाई दिए, इससे आप टेम्प्लेट फ़ंक्शंस / क्लासेस को एक तरह से लिख सकते हैं जो C ++ 03 में बिल्कुल भी असंभव था। ऐसे टेम्प्लेट कार्य को सरल बनाते हैं।

सबसे पहले, मुझे दुभाषिया के साथ सबसे सरल संचालन पर एक आवरण लिखने की ज़रूरत थी (मैं सी एपीआई लुआ के लिए सरल कॉल कर सकता था, लेकिन मैं मेमोरी में स्टैक में विभिन्न मूल्यों के अनुक्रमितों का एक गुच्छा नहीं रखना चाहता था। इसलिए, मैंने उन्हें कई कार्यों में लपेट लिया, जो बचत के अलावा भी हैं। प्रत्येक फ़ंक्शन को इंटरप्रेटर की स्थिति के लिए एक सूचक पास करने की आवश्यकता से, लगभग कोई अनुक्रमणिका की आवश्यकता नहीं होती है, क्योंकि उनके पास डिफ़ॉल्ट मान हैं।

नतीजतन, मैं निम्नलिखित के लिए एक इंटरफ़ेस देखना चाहता था:

lua.export_function(some_function); 

आप इसे आजमा सकते हैं। हालांकि, इंटरफ़ेस अभी भी थोड़ा अधिक जटिल होगा। आपको निर्यात किए गए फ़ंक्शन के लिए दुभाषिया का नाम निर्दिष्ट करना होगा। और हम फ़ंक्शन को पता पास करेंगे।

 lua.export_function("some_function", &some_function); 

हम टेम्पलेट मापदंडों के आउटपुट का उपयोग करते हैं। पैरामीटर स्वचालित रूप से प्रदर्शित किए जा सकते हैं यदि वे हैं:

• कॉलबैक का वापसी मूल्य:
  

   template <typename T> void some_function(T (*callback)()) {} 

  
  
• कॉलबैक पैरामीटर:
  

   template <typename T> void some_function(void (*callback)(T)) {} 

  
  
• विधि जिस वर्ग की है।
  

   template <typename T> void some_function(void (T::*method)()) {} 

  
  

इन सभी मामलों (और कुछ अन्य) को जोड़ा जा सकता है। आप इसका उपयोग कर सकते हैं।

 template <typename R, typename... Args> void export_function(const std::string& name, T (*function)(Args...)) { } 

अब, आप वास्तविक निर्यात फ़ंक्शन पर ले जा सकते हैं। प्रत्येक फ़ंक्शन के लिए, एक लंबर बनाएं जो दुभाषिया से तर्क लेगा, उन्हें फ़ंक्शन में पास करेगा, और फिर दुभाषिया के लिए परिणाम लौटाएगा। लैम्ब्डा को हर समय संग्रहीत किया जाना चाहिए कि दुभाषिया का उदाहरण काम कर रहा है, इसलिए मैं कक्षा के अंदर प्रत्येक लैम्ब्डा को पॉइंटर को बचाता हूं और इसे विध्वंसक में हटा देता हूं।

 template <typename R, typename... Args> void export_function(const std::string& name, T (*function)(Args...)) { auto function = new std::function<int(Lua&)>([function](Lua& vm) -> int { auto tuple = args<Args...>(); return apply_function<std::tuple_size<decltype(tuple)>::value> ::apply(function, tuple); }); lambda(function); } 

यह अजीब लग रहा है। आइए इसे जानने की कोशिश करें। पहले आपको दुभाषिया से सभी तर्क प्राप्त करने की आवश्यकता है।

 template <typename T, typename T1, typename... Args> std::tuple<T, T1, Args...> args(const int i = 1) { T t = arg<T>(i); return std::tuple_cat(t, args<T1, Args...>(i+1)); } 

हम i-th तर्क प्राप्त करते हैं और इसे वापस करते हैं, और पुनरावर्तन का उपयोग करके हमें बाकी तर्क मिलते हैं। लेकिन यह पर्याप्त नहीं है।
इस फ़ंक्शन को अतिभारित करने की आवश्यकता है ताकि अंतिम पुनरावृत्ति पर एक और कोड निष्पादित हो।

 template <typename T> std::tuple<T> args(const int i = 1) { return std::tuple<T>(arg<T>(i)); } 

आर्ग फ़ंक्शन स्पष्ट है, मैंने इसे नहीं दिया है; यह सब आवश्यक है कि कई विशेषज्ञताओं को लिखा जाए।
अब जबकि हमारे पास एक ही बात में सभी तर्क हैं, हमें उन सभी को एक समारोह में पारित करने की आवश्यकता है।

 template <int N> struct apply_function { template <typename R, typename... FunctionArgs, typename... TupleArgs, typename... Args> static R apply(R (*function)(Args...), std::tuple<TupleArgs...>, Args... args) { return apply_function<N-1>::apply(function, tuple, std::get<N-1>::value, args); } }; 

और आपको अंतिम पुनरावृत्ति के लिए इस टेम्पलेट को विशेषज्ञ बनाने की आवश्यकता है।

 template <> struct apply_function<0> { template <typename R, typename... FunctionArgs, typename... TupleArgs, typename... Args> static R apply(R (*function)(Args...), std::tuple<TupleArgs...>, Args... args) { return (*function)(args...); } }; 

इस सब के अलावा, कुछ और विशेषज्ञता की आवश्यकता होगी (शून्य प्रकार में समस्याएं)।

परिणाम

यह लुआ के लिए C ++ फ़ंक्शंस और कक्षाओं के निर्यात के लिए काफी काम करने वाला आवरण है। स्पष्ट नुकसान में से, मुझे केवल कुछ ही दिखाई देते हैं:

• लैम्ब्डा कॉलबैक की तुलना में अभी भी धीमे हैं, यदि आप चाहें, तो आप उनके बिना कोड को फिर से लिख सकते हैं, लेकिन आपको कई टेम्पलेट फ़ंक्शन मिलेंगे।
• हर बार फ़ंक्शन / विधि को कहा जाता है, हमें दो पुनरावृत्तियां मिलती हैं, जिनमें से गहराई फ़ंक्शन तर्कों की संख्या के बराबर होती है। शायद संकलक टेम्पलेट फ़ंक्शन इनलाइन के इस पूरे गिरोह को बना देगा, मैंने इसका परीक्षण नहीं किया है (और मुझे इसके बारे में निश्चित नहीं है)।
• टेम्पलेट्स संकलन समय को बहुत प्रभावित करते हैं। लेकिन यहां तक ​​कि मेरे बल्कि कमजोर लैपटॉप पर, इस रैपर और कोड का उपयोग करने वाले इसे बनाने वाले कोड की तुलना में बहुत कम समय लेते हैं, इसलिए यह महत्वपूर्ण नहीं है।
• एकाधिक वंशानुक्रम के लिए कोई समर्थन नहीं है - यह करने के लिए बहुत नीच है।
• मेटाबेबल्स तक कोई पहुंच नहीं है, जिसका अर्थ है कि ऑपरेटरों का कोई पुनर्निर्धारण नहीं है।
• फ़ंक्शन ओवरलोडिंग के लिए कोई समर्थन नहीं है, लेकिन आप बस ओवरलोड कार्यों को अलग-अलग नाम दे सकते हैं।

आखिरी तीन अंक, शायद मैं थोड़ी देर बाद करूंगा।
और अब पेशेवरों:

• सरल इंटरफ़ेस
• शुद्ध C ++ 11 में समाधान के लिए अतिरिक्त उपकरणों के साथ अतिरिक्त कोड की पीढ़ी की आवश्यकता नहीं है।

कैसे उपयोग करें

सबसे पहले, आपको उपयोग की एक वस्तु बनाने की आवश्यकता है :: लुआ वर्ग, और दुभाषिया को आरंभीकृत किया जाता है।

 util::Lua vm; 

उसके बाद, आप फ़ंक्शन / कक्षाएं निर्यात कर सकते हैं।

कार्यों

सब कुछ सरल है। हम फ़ंक्शन और नाम के लिए केवल एक पॉइंटर का उपयोग करते हैं, जिसके तहत यह लुआ में उपलब्ध होगा।

 some_function(); vm.export_function("some_function", &some_function); 

सभी मापदंडों और वापसी मूल्य के प्रकारों को सही ढंग से निर्धारित और संसाधित किया जाएगा।

कक्षाएं

निर्यातित वर्ग तैयार होना चाहिए। पहले आपको इसे उपयोग से प्राप्त करने की आवश्यकता है :: LuaClass, ताकि जब ऑब्जेक्ट वापस आए, तो दुभाषिया ऑब्जेक्ट को लौटाएगा, उपयोगकर्ताडेटा को नहीं। तीन स्थिर तरीकों को परिभाषित करने की आवश्यकता के बाद।

• Export_class विधि को कक्षा के सभी तरीकों / कार्यों को निर्यात करना चाहिए।
• Export_me विधि को Lua :: Export_class <A, B> () फ़ंक्शन को कॉल करना होगा
• Class_name विधि को वर्ग नाम वापस करना चाहिए।

 class A : public util::LuaClass { public: static void export_class(Lua& vm); static void export_me(Lua& vm); static const std::string class_name(); }; void A::export_me(Lua& vm) { vm.export_class<A>(); } class B: public A { public: static void export_class(Lua& vm); static void export_me(Lua& vm); static const std::string class_name(); }; void B::export_me(Lua& vm) { vm.export_class<B, A>(); } 

उपयोग :: Lua :: Export_class फ़ंक्शंस को टेम्प्लेट पैरामीटर के रूप में पास किया जाता है - वह वर्ग जिसे हम चाहते हैं
निर्यात और उसके माता-पिता इसे निर्यात करने के लिए (यदि पहले से नहीं किया गया है)

सबसे दिलचस्प बात Export_class पद्धति में हो रही है। उदाहरण के लिए:

 vm.export_constructor<A, int>(); vm.export_function("static_method", &A::static_method); vm.export_method("method", &A::method); 

सब कुछ सरल है। हम फ़ंक्शनल विधियों को फ़ंक्शन के रूप में, विधियों को समान तरीके से निर्यात करते हैं, लेकिन एक अलग फ़ंक्शन के माध्यम से। निर्माणकर्ता को नए नाम के एक फ़ंक्शन के रूप में निर्यात किया जाता है, इसके तर्कों के प्रकारों को स्पष्ट रूप से निर्दिष्ट किया जाना चाहिए
टेम्पलेट तर्क, यह इस तथ्य के कारण है कि आप एक पॉइंटर को निर्माता के पास नहीं ले जा सकते हैं। अच्छी बात यह है कि लुआ से इस तरह के कंस्ट्रक्टर को बुलाकर बनाई गई वस्तुएं कचरा कलेक्टर को संसाधित करेगी। जब ऑब्जेक्ट के सभी संदर्भ हटा दिए जाते हैं, तो C ++ ऑब्जेक्ट के लिए डिलीट कहा जाएगा।

कोड

सभी कोड MIT लाइसेंस के तहत github.com/alex-ac/LuaCxx github पर पोस्ट किए गए हैं।
मुझे टिप्पणी, सुझाव, सुविधा अनुरोध और बग रिपोर्ट देखने में खुशी होगी।

युपीडी

मैं लगभग भूल गया था। सभी कोड g ++ 4.7.2 का उपयोग करके बनाया गया है, g ++> = 4.6.4 और clang> = 3.0 भी काम करना चाहिए।