पोर्टेबल कंपोनेंट्स, सॉफ्टवेयर डेवलपमेंट एड्स

POCO लाइब्रेरी ( पोर्टेबल कंपोनेंट्स ) पर अपने पिछले लेख को जारी रखते हुए, मैं POCO एप्लीकेशन स्नैप-इन और उसके डेरिवेटिव जैसे कि ServerApplication और ConsoleApplication के बारे में बात करना चाहूंगा।
एप्लिकेशन स्नैप-इन को सॉफ्टवेयर विकास को आसान बनाने और, एक नियम के रूप में, समय बचाने के लिए डिज़ाइन किया गया है। इस स्नैप-इन का उपयोग करके, हम मिनटों में कंसोल एप्लिकेशन, विंडोज सेवाएं और UNIX डेमॉन बना सकते हैं।

विवरण

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

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

अभ्यास

इस स्नैप-इन का उपयोग करके एक प्रोग्राम बनाने के लिए, आपको पोको से उपयोग करना चाहिए :: Util :: अनुप्रयोग और निम्नलिखित विधियों को अधिभारित करें:

• void initialize(Application& self) //  

•  void uninitialize() //   

•  void reinitialize(Application& self) //  

•  void defineOptions() //  

•  void handleOption() //    

•  int main(const std::vector<std::string>& args) //     

अनुप्रयोग लॉन्च विकल्प

POCO में एप्लिकेशन स्टार्टअप पैरामीटर को विकल्प वर्ग का उपयोग करके कार्यान्वित किया जाता है।
प्रत्येक पैरामीटर में निम्नलिखित गुण होते हैं:

• पूरा नाम
• संक्षिप्त नाम
• चरित्र का नाम (1 वर्ण)
• विवरण

पैरामीटर को समूहीकृत किया जा सकता है और वैकल्पिक हो सकता है। आप प्रत्येक पैरामीटर के लिए मान सत्यापनकर्ता संलग्न कर सकते हैं। POCO में दो प्रकार के सत्यापनकर्ता पूर्वनिर्धारित हैं: IntValidator - संख्यात्मक मानों की जाँच करता है, RegExpValidator - नियमित अभिव्यक्ति के अनुपालन के लिए पैरामीटर की जाँच करता है। यदि प्रोग्राम उन मापदंडों के साथ लॉन्च किया गया है जो सत्यापन पारित नहीं हुए हैं, तो प्रोग्राम एक त्रुटि लौटाएगा और सभी संभावित विकल्प दिखाएगा, जो बदले में स्वचालित रूप से उत्पन्न होते हैं। आप मापदंडों पर फ़ंक्शन हैंडलर (कॉलबैक) "हैंग" कर सकते हैं, जिसे इन मापदंडों को इनिशियलाइज़ेशन के दौरान उपयोग किया जाता है।

 class myApp : public Application { public: myApp(int argc, char** argv) : Application(argc,argv) {} void initialize(Application& self) { cout << "" << endl; loadConfiguration(); //    Application::initialize(self); } void reinitialize() { cout << "" << endl; Application::uninitialize(); } void uninitialize(Application& self) { cout << "" << endl; Application::reinitialize(self); } void HelpHim(const std::string& name, const std::string& value) { cout << "  -   " << endl; } void Configure(const std::string& name, const std::string& value) { cout << "     " << endl; } void defineOptions(OptionSet& options) { cout << " " << endl; Application::defineOptions(options); options.addOption( Option("help", "h", " . ") .required(false) //  .repeatable(false) //  //myApp::handleOption - -  .callback(OptionCallback<myApp>(this, &myApp::handleOption))); options.addOption( Option("config-file", "f", "   ") .required(false) .repeatable(true) .argument("file") .callback(OptionCallback<myApp>(this, &myApp::Configure))); options.addOption( Option("bind", "b", "  =") .required(false) //  -   .argument("value") // ,  ,       [0; 100] .validator(new IntValidator(0, 100)) .binding("test.property")); //     } int main(const std::vector<std::string>& args) { cout << " -" << endl; } }; //  POCO_APP_MAIN   -  : // int wmain(int argc, wchar_t** argv) // { // myApp A(argc,argv); // return A.run(); // } POCO_APP_MAIN(myApp) 

UNIX डेमॉन और विंडोज सेवाओं को बनाने के लिए उपकरण।

एक सर्वर बनाने के लिए, कभी-कभी यह आवश्यक होता है कि इसकी प्रक्रिया किसी अन्य उपयोगकर्ता (उदाहरण के लिए, सिस्टम से) से शुरू हो और बाद वाले से संसाधन न लें। इसके अलावा, यह फ़ंक्शन ओएस स्टार्टअप पर एप्लिकेशन लॉन्च करने के लिए उपयोगी है और उपयोगकर्ता की स्थिति पर निर्भर नहीं करता है। POCO में एक सेवा या डेमॉन को लागू करना पोको से विरासत में मिला है । :: Util :: ServerApplication ।

हम कुछ कार्य के वर्ग को लागू करते हैं, जो हमारे सर्वर का तर्क होगा, उदाहरण के लिए, हर सेकंड यह लॉग को लिखेगा कि हमारे कार्यक्रम ने कितना काम किया है:

 class myServerTask: public Task { public: myServerTask(): Task("MyTask") //    "MyTask" { } //  void runTask() { Application& app = Application::instance(); while (!isCancelled()) { //  sleep(1000); //    Application::instance().logger().information ("  " + DateTimeFormatter::format(app.uptime())); } } }; 

अगला, हम सीधे सर्वर को लागू करते हैं:

 class myServer: public ServerApplication { protected: void initialize(Application& self) { //  loadConfiguration(); // ServerApplication ServerApplication::initialize(self); //       logger().setChannel(AutoPtr<FileChannel>(new FileChannel("C:\\log.log"))); //    logger().information(""); } void uninitialize() { logger().information(""); // ServerApplication ServerApplication::uninitialize(); } int main(const std::vector<std::string>& args) { if (!config().getBool("application.runAsDaemon") && !config().getBool("application.runAsService")) { //     //       cout << "   ,      " << endl; } else { //        //  //   TaskManager tm; //     tm.start(new myServerTask); //     waitForTerminationRequest(); //     tm.cancelAll(); tm.joinAll(); } // return Application::EXIT_OK; } }; //  POCO_SERVER_MAIN(myServer) 

सब कुछ, सेवा और डेमन लिखा है।
अब निम्नलिखित कुंजियों के साथ विंडोज सेवा को संकलित और पंजीकृत करें:

• Windows सेवा को पंजीकृत करने के लिए: / registerService
• विंडोज सेवा बंद करने के लिए: / unregisterService
• विंडोज सेवा का नाम बदलने के लिए: / displayName "नाम"

आवेदन शुरू करना और समाप्त करना इस प्रकार है:

• यूनिक्स डेमॉन चलाने के लिए: - काम
• विंडोज सेवा शुरू करने के लिए, कमांड लाइन चलाएं: नेट स्टार्ट <एप्लीकेशन>
• हत्यारे डेमॉन को पूरा करने के लिए <एप्लीकेशन>
• सर्विस नेट स्टॉप को पूरा करने के लिए <Application>

कॉन्फ़िगरेशन डाउनलोड करें

कॉन्फ़िगरेशन विधि द्वारा लोड किया गया है:

 void loadConfiguration(const std::string& path, int priority = PRIO_DEFAULT); 

फ़ाइल प्रकार एक्सटेंशन द्वारा निर्धारित किया जाता है:

• .properties - गुण फ़ाइल (PropertyFileConfiguration)
• .ini - प्रारंभिक फ़ाइल (IniFileConfiguration)
• .xml - XML ​​फ़ाइल (XMLConfiguration)

डेटा अपलोड होने के बाद उनका उपयोग किया जा सकता है। POCO में, एक डेटा मॉडल एक पेड़ है जिसमें प्रत्येक तत्व तक पहुंच एक स्ट्रिंग द्वारा निर्दिष्ट की जाती है।
उदाहरण के लिए XML:

 <?xml version="1.0" encoding="UTF-8"?> <recipe name="" preptime="5" cooktime="180"> <title> </title> <composition> <ingredient amount="3" unit=""></ingredient> <ingredient amount="0.25" unit=""></ingredient> <ingredient amount="1.5" unit=""> </ingredient> <ingredient amount="1" unit=" "></ingredient> </composition> <instructions> <step>     .</step> <step>         .</step> <!-- <step>  .</step> -   ... --> <step>  ,       .</step> </instructions> </recipe> 

हम इस तरह जहाज:

 void initialize(Application& self) { ofstream file("out.txt"); cout << "" << endl; loadConfiguration("a:\\conf.xml"); file << " : " << config().getString("title") << endl << "   : " << config().getString("composition.ingredient[0]") << " : " << config().getString("composition.ingredient[0][@amount]") << " " << config().getString("composition.ingredient[0][@unit]") << endl << config().getString("composition.ingredient[1]") << " : " << config().getString("composition.ingredient[1][@amount]") << " " << config().getString("composition.ingredient[1][@unit]") << endl << config().getString("composition.ingredient[2]") << " : " << config().getString("composition.ingredient[2][@amount]") << " " << config().getString("composition.ingredient[2][@unit]") << endl << config().getString("composition.ingredient[3]") << " : " << config().getString("composition.ingredient[3][@amount]") << " " << config().getString("composition.ingredient[3][@unit]") << endl << " : " << endl << config().getString("instructions.step[0]") << endl << config().getString("instructions.step[1]") << endl << config().getString("instructions.step[2]") << endl; int timeToCook = config().getInt("[@cooktime]"); file << "  : " << timeToCook << endl; file.close(); } 

परिणाम यह है:

हम पकाते हैं: साधारण रोटी
इसके लिए हमें चाहिए: आटा: 3 कप
खमीर: 0.25 ग्राम
गर्म पानी: 1.5 कप
नमक: 1 चम्मच
चरणों का पालन करें:
सभी अवयवों को मिलाएं और अच्छी तरह से गूंधें।
एक कपड़े के साथ कवर करें और एक गर्म कमरे में एक घंटे के लिए छोड़ दें।
फिर से गूंध, एक बेकिंग शीट और ओवन में रखें।
खाना पकाने का समय: 180

इसी तरह, आप पार्स और INI कर सकते हैं। तदनुसार, हमेशा "श्रेणी.की" फ़ॉर्म की पहचान होगी।
उदाहरण के लिए

 ;INI-File [Group] ValueText = "hello world" IntValue = 123 

हम इस तरह जहाज:

 std::string text = config().getString("Group.ValueText"); // text == "Hello world" int value = config().getInt("Group.IntValue"); // value == 123 

.Property फाइलों में चर का नाम ही होता है

; जावा संपत्ति फ़ाइल
Value.Text = "हैलो वर्ल्ड"
Int.Value = 123

हम इस तरह जहाज:

 std::string text = config().getString("Value.Text"); // text == "Hello world" int value = config().getInt("Int.Value"); // value == 123 

लॉगिंग टूल

लॉगिंग टूल में चार मुख्य भाग होते हैं:

• लकड़हारा
• चैनल
• डेटा संग्रहण ऑब्जेक्ट (फ़ाइल, डेटाबेस)
• फ़ॉर्मेटर

लकड़हारा श्रृंखला की वह कड़ी है जिसे हमारा एप्लिकेशन लॉग में डेटा भेजने के लिए एक्सेस करता है। लॉगिंग प्रक्रिया की इकाई एक संदेश है।
संदेश एक वस्तु है:

• डेटा स्रोत (पूर्व चयनित पाठ मान)
• डेटा - घटना के बारे में उपयोगी जानकारी युक्त एक स्ट्रिंग
• समय की मोहर
• संदेश प्राथमिकता
• प्रक्रिया पहचानकर्ता (PIDs) और प्रवाह (TID)
• कुछ वैकल्पिक विकल्प

प्राथमिकताएँ निम्न क्रम में सेट की जाती हैं (निम्न से उच्च में):

• ट्रेस जानकारी (ट्रेस)
• डीबग जानकारी (डीबग)
• तकनीकी जानकारी
• अनुस्मारक (सूचना)
• चेतावनी (चेतावनी)
• त्रुटि (त्रुटि)
• गंभीर त्रुटि
• घातक त्रुटि

डेटा को एक स्ट्रिंग द्वारा दर्शाया जाता है, लेकिन अन्य डेटा को भी इनकोड किया जा सकता है। एक टाइमस्टैम्प को माइक्रोसेकंड की सटीकता के साथ बनाया गया है।

चैनल - लकड़हारा और डेटा स्टोरेज ऑब्जेक्ट के बीच एक लिंक।
कई मूल चैनल हैं:

• ConsoleChannel - जैसा कि आप अनुमान लगा सकते हैं, यह एक चैनल है जो डेटा को मानक आउटपुट स्ट्रीम STDOUT में आउटपुट करता है
• WindowsConsoleChannel - एक विंडोज़-विशिष्ट कंसोल चैनल जो डेटा को std :: clog के लिए आउटपुट करता है
• NullChannel - सभी डेटा को अस्वीकार करता है
• SimpleFileChannel - एक फ़ाइल पर आउटपुट के लिए एक सरल चैनल, एक नई लाइन पर प्रत्येक नए संदेश के साथ। एक सिले अधिकतम फ़ाइल आकार है। प्राथमिक अधिकतम आकार से अधिक होने पर डेटा संग्रहीत करने के लिए द्वितीयक फ़ाइल का उपयोग करने में सक्षम।
• FileChannel एक ऑल-व्हील ड्राइव फाइल चैनल है। संग्रह, समय क्षेत्र, संपीड़न, अधिकतम लॉग जीवनकाल का समर्थन करता है।
• EventLogChannel एक विंडोज-विशिष्ट डेटा चैनल है जो संदेशों को विंडोज सिस्टम इवेंट लॉग में भेजने की अनुमति देता है।
• SyslogChannel - एक चैनल जो syslog डेमन सर्वर को संदेश भेजता है।
• AsyncChannel - एक पुल जो आपको किसी भी चैनल को अतुल्यकालिक रूप से संदेश भेजने की अनुमति देता है।
• SplitterChannel - एक चैनल जो आपको कई चैनलों पर एक संदेश भेजने की अनुमति देता है

लकड़हारा उपयोग करने का एक उदाहरण:

 //  AutoPtr<ConsoleChannel> console(new ConsoleChannel); //  AutoPtr<PatternFormatter> formater(new PatternFormatter); formater->setProperty("pattern", "%Y-%m-%d %H:%M:%S %s: %t"); //  AutoPtr<FormattingChannel> formatingChannel(new FormattingChannel(formater, console)); //  Logger::root().setChannel(formatingChannel); //   Logger::get("Console").information("  "); //      AutoPtr<FormattingChannel> file(new FormattingChannel(formater, AutoPtr<FileChannel>(new FileChannel("A:\\123.txt")))); //  Logger::create("File", file); //  Logger::get("File").fatal("I want to play a game.    "); //   AutoPtr<SplitterChannel> splitter(new SplitterChannel); //       splitter->addChannel(file); splitter->addChannel(console); //    Logger::create("AllChannel", file); //    Logger::get("AllChannel").fatal("    "); //    AutoPtr<EventLogChannel> event(new EventLogChannel); //  Logger::create("Event", event); //     (  Windows) Logger::get("Event").fatal("   "); 

अलग-अलग मॉड्यूल में कक्षाएं बनाना

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

 // sort.h class ABaseSort { protected: vector<int> array; //   public: ABaseSort () {} // - virtual ~ABaseSort() {} // virtual string name() const = 0; //  name ,    //    virtual void sort() = 0; //  - void loadVector(vector<int>& lArray) { array.assign(lArray.begin(), lArray.end()); } vector<int> getArray() { return array; } //Xor-swap static void swap(int &A, int &B) { A ^= B ^= A ^= B; } }; 

अगला, हम 2 छँटाई कक्षाएं बनाते हैं: बुलबुला विधि और मानक STL विधि (static_sort)

 //    // sort.cpp #include "sort.h" class bubbleSort : public ABaseSort { public: //   string name() const { return "Bubble Sort"; } //     void sort() { size_t size = array.size(); for (int i=0; i<size-1; ++i) for (int j=i; j<size; ++j) if (array[i] > array[j]) swap(array[i],array[j]); } }; //   STL (std::stable_sort) class stableSort : public ABaseSort { public: //   string name() const { return "Stable Sort"; } //     void sort() { stable_sort(array.begin(), array.end()); } }; 

यह निर्यात विकल्प जोड़ने के लिए बना हुआ है

 POCO_BEGIN_MANIFEST(ABaseSort) //   POCO_EXPORT_CLASS(bubbleSort) //     POCO_EXPORT_CLASS(stableSort) //    stable_sort POCO_END_MANIFEST 

हम परियोजना को एक गतिशील पुस्तकालय के रूप में संकलित करते हैं।
अब हम अपनी कक्षाओं का उपयोग करते हैं।

 // logic.cpp #include "sort.h" //     ABaseSort Poco::ClassLoader<ABaseSort> loader; loader.loadLibrary("myImportedFile.dll"); //   if (loader.isLibraryLoaded("myImportedFile.dll")) { //    cout << "   : " << endl; for (auto it = loader.begin(); it != loader.end(); ++it) { cout << "  '" << it->first << "': " << endl; for (auto jt = it->second->begin(); jt != it->second->end(); ++jt) { cout << jt->name() << endl; } } //  int arr[13] = {32,41,23,20,52,67,52,34,2,5,23,52,3}; vector<int> A (arr,arr+13); //   if (ABaseSort *sort = loader.create("bubbleSort")) { //    sort->loadVector(A); // sort->sort(); //  auto vect = sort->getArray(); // for (auto it = vect.begin(); it != vect.end(); ++it) cout << *it << " "; cout << endl; //    loader.classFor("bubbleSort").autoDelete(sort); } //     stableSort if (ABaseSort *sort = loader.create("stableSort")) { sort->loadVector(A); sort->sort(); auto vect = sort->getArray(); for (auto it = vect.begin(); it != vect.end(); ++it) cout << *it << " "; cout << endl; loader.classFor("stableSort").autoDelete(sort); } } 

इस प्रकार, हम कार्यक्रम के तर्क को पूरी तरह से पुन: स्थापित किए बिना बदल सकते हैं। यह अपने व्यक्तिगत मॉड्यूल को फिर से जोड़ने और कार्यक्रम के लिए उन्हें "फीड" करने के लिए पर्याप्त है।

निष्कर्ष

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

लेख पढ़ने के लिए धन्यवाद। यथोचित आलोचना और सुझावों का स्वागत है।