🏝️ 💇🏿 👨🏿‍💼 RMI का अर्थ है C ++ और boost.preprocessor ♍️ 👩🏼‍🎓 🤣

इस संसाधन पर यह मेरा पहला प्रकाशन है, इसलिए, मैं आपसे अपनी गलतियों को समझने के लिए इलाज करने के लिए कहता हूं।

आरएमआई आत्मनिरीक्षण सक्षम पीएल के लिए एक बहुत ही तुच्छ कार्य है। लेकिन, सी ++, दुर्भाग्य से, उन पर लागू नहीं होता है।

इस प्रकाशन में, मैं C ++ प्रीप्रोसेसर का उपयोग करके एक बहुत ही उपयोगी आरएमआई को लागू करने की संभावना प्रदर्शित करना चाहता हूं।

समस्या का बयान

1. सबसे सरल वाक्यविन्यास प्रदान करें ताकि गलती करना असंभव हो।
2. प्रक्रियाओं की पहचान (लिंकिंग) को उपयोगकर्ता से छिपाया जाना चाहिए ताकि गलती करना असंभव हो।
3. सिंटैक्स का उपयोग C ++ प्रकारों पर प्रतिबंध नहीं लगाना चाहिए।
4. संस्करणित प्रक्रियाओं की संभावना होनी चाहिए, लेकिन ताकि मौजूदा ग्राहकों के साथ संगतता टूट न जाए।

चौथे बिंदु के बारे में:
उदाहरण के लिए, हमारे पास पहले से ही दो ऐड / div प्रक्रियाएं हैं, प्रत्येक का एक संस्करण। हम एक नया संस्करण जोड़ना चाहते हैं। यदि आप सिर्फ एक और संस्करण जोड़ते हैं, तो प्रक्रिया आईडी जो क्लाइंट प्रोग्राम को परिवर्तन से पहले एकत्र किया गया था, तैर जाएगी।

उपकरण चयन

क्योंकि अंतिम परिणाम C ++ कोड के साथ संयोजन में उपयोग किया जाना चाहिए, मुझे तीन विकल्प दिखाई देते हैं:

हम वाक्य रचना का आविष्कार करते हैं और अपने स्वयं के कोड जनरेटर लिखते हैं।
हम C ++ प्रीप्रोसेसर का उपयोग करते हैं।
हम कुछ तैयार कर रहे हैं और इसे अपने लिए (यदि आवश्यक हो) समाप्त कर रहे हैं।

मैं क्रमशः प्रत्येक विकल्प के बारे में बोलूंगा:

कोड पीढ़ी का एक अतिरिक्त चरण क्यों?
मैं प्रीप्रोसेसर से प्यार करता हूं, और अक्सर इसका इस्तेमाल करता हूं।
समय और प्रयास की बर्बादी। और यह स्पष्ट नहीं है कि क्या यह समझ में आता है।

आवश्यकताओं के पहले, दूसरे और तीसरे पैराग्राफ के बारे में - प्रीप्रोसेसर संस्करण उपयुक्त है।

तो, चुनाव किया जाता है - हम प्रीप्रोसेसर का उपयोग करते हैं। और हां, जरूर बढ़ाएं।प्रोसेसर ।

प्रीप्रोसेसर के बारे में थोड़ा सा

C ++ प्रीप्रोसेसर डेटा प्रकार:

सरणियाँ : (size, (elems, ....))
सूचियाँ : (a, (b, (c, BOOST_PP_NIL)))
अनुक्रम : (a)(b)(c)
टुपल्स : (a, b, c)

प्रकार, जैसा कि देखा जा सकता है, पर्याप्त से अधिक हैं।
थोड़ा विचार करने के बाद, उनमें से प्रत्येक की संभावनाओं और सीमाओं के बारे में पढ़ना, और सिंटैक्स की वांछित सादगी और गलती करने की अक्षमता को भी ध्यान में रखना - चुनाव अनुक्रमों और ट्यूपल्स के पक्ष में किया गया था।

कुछ उदाहरण हैं।
(a)(b)(c) - अनुक्रम यहाँ, हमने तीन तत्वों से मिलकर एक अनुक्रम का वर्णन किया।
(a) भी एक अनुक्रम है, लेकिन एक तत्व से मिलकर बनता है। (सावधान!)
(a)(b, c)(d, e, f) - फिर से एक अनुक्रम, लेकिन तीन tuples से मिलकर। (पहले तत्व पर ध्यान दें - एक चाल, हालांकि, लेकिन यह वास्तव में तुच्छ है)
(a)(b, c)(d, (e, f)) - फिर से एक अनुक्रम, और तीन ट्यूपल से मिलकर भी। लेकिन! अंतिम टपल में दो तत्व होते हैं: 1) कोई भी तत्व, 2) टपल।
और अंत में, इस तरह के एक उदाहरण: (a)(b, c)(d, (e, (f)(g))) - यहां आप इसे खुद समझ सकते हैं;)
जाहिर है, सब कुछ वास्तव में अनुचित रूप से सरल है।

प्रोटोटाइप सिंटैक्स

कुछ विचार के बाद, निम्नलिखित सिंटैक्स उभरता है:

 (proc_name0, //   (signature_arg0, signature_arg1, signature_argN) //    (signature_arg0) //    ) (proc_name1, //   (signature_arg0, signature_arg1) //     ) (proc_name2, //   () //     ( ) )

खैर ... हालांकि, बहुत पहले से ही।

कुछ कार्यान्वयन विवरण

क्योंकि आवश्यकताओं में से एक प्रक्रियाओं का संस्करण है, और यहां तक कि मौजूदा ग्राहकों के साथ संगतता नहीं टूटती है - प्रक्रियाओं की पहचान करने के लिए हमें दो आईडी की आवश्यकता होगी। पहला प्रक्रिया आईडी है, दूसरा संस्करण आईडी है।

मैं एक उदाहरण के साथ समझाऊंगा।
मान लीजिए कि यह हमारी सेवा के एपीआई का विवरण है। मान लीजिए कि हमारे पास पहले से ही इस एपीआई का उपयोग करने वाले ग्राहक कार्यक्रम हैं।

 (proc_name0, // procID=0 (signature_arg0, signature_arg1) // sigID=0 ) (proc_name1, // procID=1 (signature_arg0, signature_arg1) // sigID=0 ) (proc_name2, // procID=2 () // sigID=0 )

अब, proc_name0() हमें एक अलग हस्ताक्षर के साथ एक और संस्करण जोड़ना होगा।

 (proc_name0, // procID=0 (signature_arg0, signature_arg1) // sigID=0 (signature_arg0, signature_arg1, signature_arg2) // sigID=1 ) (proc_name1, // procID=1 (signature_arg0, signature_arg1) // sigID=0 ) (proc_name2, // procID=2 () // sigID=0 )

इस प्रकार, हमारे पास प्रक्रिया का एक नया आईडी संस्करण है, जबकि पूर्व अपरिवर्तित रहा।
यह था: (0: 0), यह बन गया: (0: 0) (0: 1)
यानी यह वही है जो हमने हासिल करने की कोशिश की थी। पिछले ग्राहकों ने दोनों (0: 0) का उपयोग किया और इन पहचानकर्ताओं का उपयोग किए बिना चिंता किए रहेंगे कि इन प्रक्रियाओं के नए संस्करण दिखाई दिए हैं।
हम यह भी मानते हैं कि सभी नई प्रक्रियाओं को अंत तक जोड़ा जाना चाहिए।

इसके बाद, हमें यह सुनिश्चित करने की आवश्यकता है कि आईडी सेवा के दोनों ओर स्वचालित रूप से चिपकाए गए हैं। आसानी से! - बस क्लाइंट और सर्वर साइड उत्पन्न करने के लिए दो बार एक ही वर्णित अनुक्रम का उपयोग करें!

यह कल्पना करने का समय है कि हम लंबे समय में यह सब कैसे देखना चाहते हैं:

 MACRO( client_invoker, // name of the client invoker implementation class ((registration, // procedure name ((std::string, std::string)) // message : registration key )) ((activation, ((std::string)) // message )) ((login, ((std::string)) // message )) ((logout, ((std::string)) // message )) ((users_online, ((std::vector<std::string>)) // without args )) , server_invoker, // name of the server invoker implementation class ((registration, ((std::string)) // username )) ((activation, ((std::string, std::string, std::string)) // registration key : username : password )) ((login, ((std::string, std::string)) // username : password )) ((logout, (()) // without args )) ((users_online, (()) // without args ((std::string)) // substring )) )

ताकि कोई भ्रम न हो कि कौन नेता है और कौन गुलाम है, हम इस बात से सहमत हैं कि किसी एक पक्ष पर वर्णित प्रक्रियाएं कार्यान्वयन हैं जो विपरीत दिशा में हैं। यह है, उदाहरण के लिए, client_invoker::registration(std::string, std::string) हमें बताता है कि इस प्रक्रिया का कार्यान्वयन सर्वर की तरफ होगा, जबकि इस प्रक्रिया का इंटरफ़ेस साइड में होगा ग्राहक, और इसके विपरीत।
(हम डबल कोष्ठक का उपयोग करते हैं क्योंकि प्रीप्रोसेसर, जब हमारे MACRO () के लिए तर्क उत्पन्न करता है, हमारे द्वारा वर्णित एपीआई का विस्तार करता है। इसे दूर किया जा सकता है, लेकिन मुझे पता नहीं है कि क्या यह आवश्यक है? ..

परिणाम

ऊपर मैक्रो कॉल से, स्पॉइलर के नीचे का कोड उत्पन्न होगा।

कोड

 namespace yarmi { template<typename Impl, typename IO = Impl> struct client_invoker { client_invoker(Impl &impl, IO &io) :impl(impl) ,io(io) {} void yarmi_error(const std::uint8_t &arg0, const std::uint8_t &arg1, const std::string &arg2) { yas::binary_mem_oarchive oa(yas::no_header); oa & static_cast<std::uint8_t>(0) & static_cast<std::uint8_t>(0) & arg0 & arg1 & arg2; yas::binary_mem_oarchive pa; pa & oa.get_intrusive_buffer(); io.send(pa.get_shared_buffer()); } void registration(const std::string &arg0) { yas::binary_mem_oarchive oa(yas::no_header); oa & static_cast<std::uint8_t>(1) & static_cast<std::uint8_t>(0) & arg0; yas::binary_mem_oarchive pa; pa & oa.get_intrusive_buffer(); io.send(pa.get_shared_buffer()); } void activation(const std::string &arg0, const std::string &arg1, const std::string &arg2) { yas::binary_mem_oarchive oa(yas::no_header); oa & static_cast<std::uint8_t>(2) & static_cast<std::uint8_t>(0) & arg0 & arg1 & arg2; yas::binary_mem_oarchive pa; pa & oa.get_intrusive_buffer(); io.send(pa.get_shared_buffer()); } void login(const std::string &arg0, const std::string &arg1) { yas::binary_mem_oarchive oa(yas::no_header); oa & static_cast<std::uint8_t>(3) & static_cast<std::uint8_t>(0) & arg0 & arg1; yas::binary_mem_oarchive pa; pa & oa.get_intrusive_buffer(); io.send(pa.get_shared_buffer()); } void logout() { yas::binary_mem_oarchive oa(yas::no_header); oa & static_cast<std::uint8_t>(4) & static_cast<std::uint8_t>(0); yas::binary_mem_oarchive pa; pa & oa.get_intrusive_buffer(); io.send(pa.get_shared_buffer()); } void users_online() { yas::binary_mem_oarchive oa(yas::no_header); oa & static_cast<std::uint8_t>(5) & static_cast<std::uint8_t>(0); yas::binary_mem_oarchive pa; pa & oa.get_intrusive_buffer(); io.send(pa.get_shared_buffer()); } void users_online(const std::string &arg0) { yas::binary_mem_oarchive oa(yas::no_header); oa & static_cast<std::uint8_t>(5) & static_cast<std::uint8_t>(1) & arg0; yas::binary_mem_oarchive pa; pa & oa.get_intrusive_buffer(); io.send(pa.get_shared_buffer()); } void invoke(const char *ptr, std::size_t size) { std::uint8_t call_id, call_version; static const char* names[] = { "yarmi_error" ,"registration" ,"activation" ,"login" ,"logout" ,"users_online" }; static const std::uint8_t versions[] = { 0, 0, 0, 0, 0, 0 }; try { yas::binary_mem_iarchive ia(ptr, size, yas::no_header); ia & call_id & call_version; if ( call_id < 0 || call_id > 5 ) { char errstr[1024] = {0}; std::snprintf( errstr ,sizeof(errstr) ,"%s::%s(): bad call_id %d" ,"client_invoker" ,__FUNCTION__ ,static_cast<int>(call_id) ); throw std::runtime_error(errstr); } if ( call_version > versions[call_id] ) { char errstr[1024] = {0}; std::snprintf( errstr ,sizeof(errstr) ,"%s::%s(): bad call_version %d for call_id %d(%s::%s())" ,"client_invoker" ,__FUNCTION__ ,static_cast<int>(call_version) ,static_cast<int>(call_id) ,"client_invoker" ,names[call_id] ); throw std::runtime_error(errstr); } switch ( call_id ) { case 0: { std::uint8_t arg0; std::uint8_t arg1; std::string arg2; ia & arg0 & arg1 & arg2; impl.on_yarmi_error( arg0 , arg1 , arg2); }; break; case 1: { std::string arg0; std::string arg1; ia & arg0 & arg1; impl.on_registration(arg0, arg1); }; break; case 2: { std::string arg0; ia & arg0; impl.on_activation(arg0); }; break; case 3: { std::string arg0; ia & arg0; impl.on_login(arg0); }; break; case 4: { std::string arg0; ia & arg0; impl.on_logout(arg0); }; break; case 5: { std::vector<std::string> arg0; ia & arg0; impl.on_users_online(arg0); }; break; } } catch (const std::exception &ex) { char errstr[1024] = {0}; std::snprintf( errstr ,sizeof(errstr) ,"std::exception is thrown when %s::%s() is called: '%s'" ,"client_invoker" ,names[call_id] ,ex.what() ); yarmi_error(call_id, call_version, errstr); } catch (...) { char errstr[1024] = {0}; std::snprintf( errstr ,sizeof(errstr) ,"unknown exception is thrown when %s::%s() is called" ,"client_invoker" ,names[call_id] ); yarmi_error(call_id, call_version, errstr); } } private: Impl &impl; IO &io; }; // struct client_invoker template<typename Impl, typename IO = Impl> struct server_invoker { server_invoker(Impl &impl, IO &io) :impl(impl) ,io(io) {} void yarmi_error(const std::uint8_t &arg0, const std::uint8_t &arg1, const std::string &arg2) { yas::binary_mem_oarchive oa(yas::no_header); oa & static_cast<std::uint8_t>(0) & static_cast<std::uint8_t>(0) & arg0 & arg1 & arg2; yas::binary_mem_oarchive pa; pa & oa.get_intrusive_buffer(); io.send(pa.get_shared_buffer()); } void registration(const std::string &arg0, const std::string &arg1) { yas::binary_mem_oarchive oa(yas::no_header); oa & static_cast<std::uint8_t>(1) & static_cast<std::uint8_t>(0) & arg0 & arg1; yas::binary_mem_oarchive pa; pa & oa.get_intrusive_buffer(); io.send(pa.get_shared_buffer()); } void activation(const std::string &arg0) { yas::binary_mem_oarchive oa(yas::no_header); oa & static_cast<std::uint8_t>(2) & static_cast<std::uint8_t>(0) & arg0; yas::binary_mem_oarchive pa; pa & oa.get_intrusive_buffer(); io.send(pa.get_shared_buffer()); } void login(const std::string &arg0) { yas::binary_mem_oarchive oa(yas::no_header); oa & static_cast<std::uint8_t>(3) & static_cast<std::uint8_t>(0) & arg0; yas::binary_mem_oarchive pa; pa & oa.get_intrusive_buffer(); io.send(pa.get_shared_buffer()); } void logout(const std::string &arg0) { yas::binary_mem_oarchive oa(yas::no_header); oa & static_cast<std::uint8_t>(4) & static_cast<std::uint8_t>(0) & arg0; yas::binary_mem_oarchive pa; pa & oa.get_intrusive_buffer(); io.send(pa.get_shared_buffer()); } void users_online(const std::vector<std::string> &arg0) { yas::binary_mem_oarchive oa(yas::no_header); oa & static_cast<std::uint8_t>(5) & static_cast<std::uint8_t>(0) & arg0; yas::binary_mem_oarchive pa; pa & oa.get_intrusive_buffer(); io.send(pa.get_shared_buffer()); } void invoke(const char *ptr, std::size_t size) { std::uint8_t call_id, call_version; static const char* names[] = { "yarmi_error" ,"registration" ,"activation" ,"login" ,"logout" ,"users_online" }; static const std::uint8_t versions[] = { 0, 0, 0, 0, 0, 1 }; try { yas::binary_mem_iarchive ia(ptr, size, yas::no_header); ia & call_id & call_version; if ( call_id < 0 || call_id > 5 ) { char errstr[1024] = {0}; std::snprintf( errstr ,sizeof(errstr) ,"%s::%s(): bad call_id %d" ,"server_invoker" ,__FUNCTION__ ,static_cast<int>(call_id) ); throw std::runtime_error(errstr); } if ( call_version > versions[call_id] ) { char errstr[1024] = {0}; std::snprintf( errstr ,sizeof(errstr) ,"%s::%s(): bad call_version %d for call_id %d(%s::%s())" ,"server_invoker" ,__FUNCTION__ ,static_cast<int>(call_version) ,static_cast<int>(call_id) ,"server_invoker" ,names[call_id] ); throw std::runtime_error(errstr); } switch ( call_id ) { case 0: { std::uint8_t arg0; std::uint8_t arg1; std::string arg2; ia & arg0 & arg1 & arg2; impl.on_yarmi_error(arg0, arg1, arg2); }; break; case 1: { std::string arg0; ia & arg0; impl.on_registration(arg0); }; break; case 2: { std::string arg0; std::string arg1; std::string arg2; ia & arg0 & arg1 & arg2; impl.on_activation(arg0, arg1, arg2); }; break; case 3: { std::string arg0; std::string arg1; ia & arg0 & arg1; impl.on_login(arg0, arg1); }; break; case 4: { impl.on_logout(); }; break; case 5: { switch ( call_version ) { case 0: { impl.on_users_online(); }; break; case 1: { std::string arg0; ia & arg0; impl.on_users_online(arg0); }; break; } }; break; } } catch (const std::exception &ex) { char errstr[1024] = {0}; std::snprintf( errstr ,sizeof(errstr) ,"std::exception is thrown when %s::%s() is called: '%s'" ,"server_invoker" ,names[call_id] ,ex.what() ); yarmi_error(call_id, call_version, errstr); } catch (...) { char errstr[1024] = {0}; std::snprintf( errstr ,sizeof(errstr) ,"unknown exception is thrown when %s::%s() is called" ,"server_invoker" ,names[call_id] ); yarmi_error(call_id, call_version, errstr); } } private: Impl &impl; IO &io; }; // struct server_invoker } // ns yarmi

(मेरी अन्य परियोजना, YAS, क्रमांकन के रूप में प्रयोग की जाती है)

एक बोनस के रूप में, yarmi_error() सिस्टम प्रक्रिया को जोड़ा गया था - इसका उपयोग विपरीत पक्ष को सूचित करने के लिए किया जाता है कि कॉल करने का प्रयास करते समय एक त्रुटि हुई। ध्यान से देखें, client_invoker::invoke() , deserialization और मंगलाचरण को एक try{}catch() में लपेटा जाता है try{}catch() ब्लॉक, और yarmi_error() catch() में कहा जाता है catch() ब्लॉक। इस प्रकार, यदि किसी प्रक्रिया को डिसेर्बलाइज या कॉल करते समय कोई अपवाद होता है, तो उसे catch() ब्लॉक से सफलतापूर्वक पकड़ा जाएगा, और अपवाद की जानकारी कॉलिंग पार्टी को भेजी जाएगी। विपरीत दिशा में भी वही होगा। यानी यदि सर्वर ने कॉल के दौरान क्लाइंट को प्रक्रिया कहा है, तो एक अपवाद हुआ - क्लाइंट सर्वर को त्रुटि की जानकारी भेजेगा, इसके अलावा कॉल के आईडी और संस्करण की रिपोर्टिंग भी करेगा जिसमें अपवाद हुआ। लेकिन आप स्वयं yarmi_error() उपयोग कर सकते हैं, इसमें से कोई भी निषिद्ध नहीं है। उदाहरण: yarmi_error(call_id, version_id, "message");

जैसा कि आपने देखा होगा, उपसर्ग on_ उनके कार्यान्वयन के पक्ष में हमारे द्वारा वर्णित प्रक्रियाओं के नामों में जोड़ा जाता है

server_invoker और server_invoker दो मापदंडों को स्वीकार करते हैं। उनका पहला तल वह वर्ग है जिसमें कहा जाता है प्रक्रियाओं को लागू किया जाता है, दूसरा वह वर्ग है जिसमें send(yas::shared_buffer buf) विधि send(yas::shared_buffer buf) लागू की जाती है।
यदि आपके पास एक ही कक्षा में दोनों भूमिकाएं हैं, तो आप यह कर सकते हैं:

 struct client_session: yarmi::client_base<client_session>, yarmi::client_invoker<client_session> { client_session(boost::asio::io_service &ios) :yarmi::client_base<client_session>(ios, *this) ,yarmi::client_invoker<client_session>(*this, *this) // <<<<<<<<<<<<<<<<<<<<<<<<< {} };

अंतिम संस्करण इस तरह दिखता है:

 struct client_session: yarmi::client_base<client_session>, yarmi::client_invoker<client_session> { client_session(boost::asio::io_service &ios) :yarmi::client_base<client_session>(ios, *this) ,yarmi::client_invoker<client_session>(*this, *this) {} void on_registration(const std::string &msg, const std::string ®key) {} void on_activation(const std::string &msg) {} void on_login(const std::string &msg) {} void on_logout(const std::string &msg) {} void on_users_online(const std::vector<std::string> &users) {} };

विपरीत दिशा में इंटरफ़ेस yarmi::client_invoker के पूर्वजों से विरासत में yarmi::client_invoker । उदाहरण के लिए, हमारे client_session के निर्माता के client_session , आप registration() प्रक्रिया को निम्नानुसार कॉल कर सकते हैं:

 { registration("niXman"); }

हमें हमारे कार्यान्वयन में उत्तर मिलेगा client_session::on_registration(std::string msg, std::string regkey)
वह सब है!

कमियों में से, निम्नलिखित पर ध्यान दिया जाना चाहिए:
कमांड का उपयोग प्रक्रियाओं का वर्णन करने वाले नामों में नहीं किया जा सकता है, क्योंकि प्रीप्रोसेसर उस संदर्भ को नहीं समझता है जिसमें वे उपयोग किए जाते हैं। यह तय हो जाएगा।

अंततः, यह सब YARMI नामक एक परियोजना के परिणामस्वरूप हुआ (फिर भी एक और RMI)।
वर्णित कोड जनरेटर एक फ़ाइल में इनकोड किया गया है - yarmi.hpp । कुल मिलाकर, कोड जनरेटर को लागू करने में एक दिन का व्यवसाय हुआ।

इस पूरी चीज़ के उपयोग का एक उदाहरण यहाँ और यहाँ देखा जा सकता है । पहला परीक्षण प्रोजेक्ट अभी भी पूरा नहीं हुआ है, दुर्भाग्य से।

वर्णित के अलावा, परियोजना पृष्ठ पर आपको एसिंक्रोनस बहु-उपयोगकर्ता एकल-थ्रेडेड सर्वर और क्लाइंट कोड के कोड मिलेंगे।

एक निष्कर्ष के बजाय

योजनाओं:
1. कई इंटरफेस की पीढ़ी
2. विनिर्देश का वर्णन करें (हालांकि यह कहीं अधिक सरल है)
3. अपने लोकेटर का उपयोग करने की क्षमता

मैं रचनात्मक आलोचना और सुझावों के लिए आभारी रहूंगा।

पुनश्च
इस कोड का उपयोग हमारी कई वाणिज्यिक परियोजनाओं में, खेल देव में किया जाता है।

RMI का अर्थ है C ++ और boost.preprocessor