Erlang 21

registry




erlang

registry

C लाइब्रेरी

रजिस्ट्री

लाइब्रेरी सारांश

स्टोर करें और कुंजी-मूल्य जोड़े का बैकअप लें।

विवरण

यह मॉड्यूल रजिस्ट्री के रूप में ज्ञात तालिका में कुंजी-मूल्य वाले जोड़े को संग्रहीत करने के लिए समर्थन प्रदान करता है, एक परमाणु तरीके से Mnesia को रजिस्ट्रियों का समर्थन करता है, और बाद में Mnesia से एक रजिस्ट्री की सामग्री को पुनर्स्थापित करता है।

निर्यात

int ei_reg_close(reg)

प्रकार

एक रजिस्ट्री जो पहले ei_reg_open() के साथ बनाई गई है और बंद है, और इसमें शामिल सभी ऑब्जेक्ट्स को मुक्त कर दिया गया है।

reg को बंद करने के लिए रजिस्ट्री है।

लौटता है 0

int ei_reg_delete(reg,key)

प्रकार

रजिस्ट्री से ऑब्जेक्ट हटाता है। ऑब्जेक्ट को रजिस्ट्री से हटाया नहीं जाता है, इसे केवल बाद में हटाने के लिए चिह्नित किया जाता है ताकि बाद में Mnesia लिए बैकअप पर, संबंधित वस्तु को Mnesia तालिका से भी हटाया जा सके। यदि बाद में किसी अन्य ऑब्जेक्ट को उसी कुंजी के साथ बनाया जाता है, तो ऑब्जेक्ट का पुन: उपयोग किया जाएगा।

ei_reg_dump() या ei_reg_purge() कॉल के बाद ऑब्जेक्ट को रजिस्ट्री से हटा दिया जाता है।

  • reg एक रजिस्ट्री युक्त key
  • key हटाने की वस्तु है।

सफलता पर 0 लौटता है, अन्यथा -1

int ei_reg_dump(fd,reg,mntab,flags)

प्रकार

एक रजिस्ट्री की सामग्री को एक परमाणु तरीके से Mnesia तालिका में Mnesia जाता है, अर्थात, या तो सभी डेटा या कोई डेटा अपडेट नहीं किया जाता है। यदि डेटा का बैकअप लेते समय कोई त्रुटि सामने आती है, तो संपूर्ण ऑपरेशन निरस्त कर दिया जाता है।

  • fd Erlang के लिए एक खुला संबंध है। Mnesia 3.0 या बाद में Erlang नोड पर चलना चाहिए।
  • reg बैक अप करने के लिए रजिस्ट्री है।
  • mntab Mnesia तालिका का नाम है, जहाँ समर्थित डेटा को रखा जाना है। यदि तालिका मौजूद नहीं है, तो इसे कॉन्फ़िगर करने योग्य चूक का उपयोग करके स्वचालित रूप से बनाया जाता है। इस व्यवहार को कॉन्फ़िगर करने के बारे में जानकारी के लिए, Mnesia देखें।

यदि flags 0 , तो बैकअप में केवल वे ऑब्जेक्ट शामिल हैं जो अंतिम बैकअप या पुनर्स्थापना (यानी, एक वृद्धिशील बैकअप) के बाद से बनाए, संशोधित या हटाए गए हैं। बैकअप के बाद, कोई भी ऑब्जेक्ट जो गंदे के रूप में चिह्नित किया गया था, अब साफ है, और किसी भी ऑब्जेक्ट को हटाने के लिए चिह्नित किया गया था।

वैकल्पिक रूप से, EI_FORCE को झंडे सेट करने से पूर्ण बैकअप हो जाता है, और EI_NOPURGE हटाए गए ऑब्जेक्ट को बाद में रजिस्ट्री में छोड़ दिया जाता है। यदि दोनों व्यवहार वांछित हैं तो ये एक साथ बिट या ऑर्ड हो सकते हैं। यदि EI_NOPURGE निर्दिष्ट किया गया था, तो ei_reg_purge() का उपयोग बाद में रजिस्ट्री से हटाए गए आइटमों को स्पष्ट रूप से हटाने के लिए किया जा सकता है।

सफलता पर 0 लौटता है, अन्यथा -1

double ei_reg_getfval(reg,key)

प्रकार

रजिस्ट्री में key के साथ जुड़े मूल्य हो जाता है। मान एक अस्थायी बिंदु प्रकार होना चाहिए।

  • reg वह रजिस्ट्री है जहां ऑब्जेक्ट को देखा जाएगा।
  • key को देखने के लिए वस्तु का नाम है।

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

int ei_reg_getival(reg,key)

प्रकार

रजिस्ट्री में key के साथ जुड़े मूल्य हो जाता है। मान पूर्णांक होना चाहिए।

  • reg वह रजिस्ट्री है जहां ऑब्जेक्ट को देखा जाएगा।
  • key को देखने के लिए वस्तु का नाम है।

सफलता पर, फ़ंक्शन key के साथ जुड़े मूल्य को लौटाता है। यदि ऑब्जेक्ट नहीं मिला है या यदि यह पूर्णांक ऑब्जेक्ट नहीं है, तो -1 लौटा है। इन-बैंड त्रुटि रिपोर्टिंग के साथ समस्याओं से बचने के लिए (यदि आप -1 और वैध परिणाम के बीच अंतर नहीं कर सकते हैं), इसके बजाय अधिक सामान्य फ़ंक्शन ei_reg_getval() उपयोग करें।

const void *ei_reg_getpval(reg,key,size)

प्रकार

रजिस्ट्री में key के साथ जुड़े मूल्य हो जाता है। मान एक बाइनरी (पॉइंटर) प्रकार होना चाहिए।

  • reg वह रजिस्ट्री है जहां ऑब्जेक्ट को देखा जाएगा।
  • key को देखने के लिए वस्तु का नाम है।
  • size ऑब्जेक्ट के बाइट्स में लंबाई को समाहित करने के लिए आरंभीकृत किया जाता है, अगर यह पाया जाता है।

सफलता पर, फ़ंक्शन key जुड़ा मान लौटाता है और size में इसकी लंबाई इंगित करता है। यदि ऑब्जेक्ट नहीं मिला है या यदि यह बाइनरी ऑब्जेक्ट नहीं है, तो NULL वापस आ गया है। इन-बैंड त्रुटि रिपोर्टिंग के साथ समस्याओं से बचने के लिए (यदि आप NULL और वैध परिणाम के बीच अंतर नहीं कर सकते हैं), इसके बजाय अधिक सामान्य फ़ंक्शन ei_reg_getval() उपयोग करें।

const char *ei_reg_getsval(reg,key)

प्रकार

रजिस्ट्री में key के साथ जुड़े मूल्य हो जाता है। मान एक स्ट्रिंग होना चाहिए।

  • reg वह रजिस्ट्री है जहां ऑब्जेक्ट को देखा जाएगा।
  • key को देखने के लिए वस्तु का नाम है।

सफलता पर, फ़ंक्शन key के साथ जुड़े मूल्य को लौटाता है। यदि ऑब्जेक्ट नहीं मिला है या यदि यह एक स्ट्रिंग नहीं है, तो NULL वापस आ गया है। इन-बैंड त्रुटि रिपोर्टिंग के साथ समस्याओं से बचने के लिए (यदि आप NULL और वैध परिणाम के बीच अंतर नहीं कर सकते हैं), इसके बजाय अधिक सामान्य फ़ंक्शन ei_reg_getval() उपयोग करें।

int ei_reg_getval(reg,key,flags,v,...)

प्रकार

रजिस्ट्री से किसी भी प्रकार की वस्तु को पुनः प्राप्त करने का एक सामान्य कार्य।

  • reg वह रजिस्ट्री है जहां ऑब्जेक्ट को देखा जाएगा।

  • key को देखने के लिए वस्तु का नाम है।

  • flags उस वस्तु के प्रकार को इंगित करते हैं जिसे आप खोज रहे हैं। यदि flags 0 , तो किसी भी प्रकार की वस्तु वापस कर दी जाती है। यदि flags EI_INT , EI_FLT , EI_STR , या EI_BIN , तो उस प्रकार के केवल मान लौटाए जाते हैं।

    v द्वारा इंगित किया गया बफर रिटर्न डेटा को रखने के लिए पर्याप्त बड़ा होना चाहिए, अर्थात, यह क्रमशः, double , char* या void* से किसी एक का सूचक होना चाहिए।

    यदि flags EI_BIN , तो एक पांचवें तर्क int *size की आवश्यकता होती है, ताकि वस्तु का आकार वापस किया जा सके।

सफलता पर, v (और size यदि ऑब्जेक्ट बाइनरी है) को key के साथ जुड़े मूल्य के साथ आरंभीकृत किया जाता है, और फ़ंक्शन EI_INT , EI_FLT , EI_STR , या EI_BIN , जो ऑब्जेक्ट के प्रकार को दर्शाता है। विफलता पर, -1 लौटा दिया जाता है और तर्क अपडेट नहीं किए जाते हैं।

int ei_reg_markdirty(reg,key)

प्रकार

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

  • reg ऑब्जेक्ट वाली रजिस्ट्री है।
  • key को चिह्नित करने के लिए ऑब्जेक्ट का नाम है।

सफलता पर 0 लौटता है, अन्यथा -1

ei_reg *ei_reg_open(size)

प्रकार

एक रजिस्ट्री खोलता है (बनाता है), जो शुरू में खाली है। रजिस्ट्री को बाद में बंद करने के लिए, ei_reg_close() उपयोग करें।

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

खाली रजिस्ट्री को सफलता पर लौटाता है, अन्यथा NULL

int ei_reg_purge(reg)

प्रकार

हटाने के लिए चिह्नित सभी वस्तुओं को निकालता है। जब ऑब्जेक्ट्स को ei_reg_delete() साथ हटा दिया जाता है तो उन्हें रजिस्ट्री से हटाया नहीं जाता है, केवल बाद में हटाने के लिए चिह्नित किया जाता है। Mnesia लिए बाद के बैकअप पर, ऑब्जेक्ट को Mnesia तालिका से भी हटाया जा सकता है। यदि आप Mnesia तक का समर्थन नहीं कर रहे हैं, तो आप इस फ़ंक्शन के साथ वस्तुओं को मैन्युअल रूप से हटाने की इच्छा कर सकते हैं।

reg एक रजिस्ट्री है जिसमें हटाने के लिए चिह्नित ऑब्जेक्ट हैं।

सफलता पर 0 लौटता है, अन्यथा -1

int ei_reg_resize(reg,newsize)

प्रकार

एक रजिस्ट्री का आकार बदलता है।

newsize रजिस्ट्री बनाने के लिए नया आकार है। संख्या को निकटतम बड़ी संख्या में बढ़ाया जाता है।

सफलता मिलने पर, रजिस्ट्री का आकार बदल दिया जाता है, सभी सामग्री को पुनः साझा कर दिया जाता है, और 0 वापस कर दिया जाता है। विफलता पर, रजिस्ट्री को अपरिवर्तित छोड़ दिया जाता है और -1 वापस कर दिया जाता है।

int ei_reg_restore(fd,reg,mntab)

प्रकार

एक Mnesia तालिका की सामग्री को रजिस्ट्री में पढ़ा जाता है।

  • fd Erlang के लिए एक खुला संबंध है। Mnesia 3.0 या बाद में Erlang नोड पर चलना चाहिए।
  • reg वह रजिस्ट्री है जहां डेटा रखा जाना है।
  • डेटा को पढ़ने के लिए Mnesia तालिका का नाम है।

ध्यान दें कि एक निश्चित प्रारूप की केवल तालिकाएँ ही पुनर्स्थापित की जा सकती हैं, ei_reg_dump() साथ बनाया और समर्थित किया गया है। यदि ऑपरेशन से पहले रजिस्ट्री खाली नहीं थी, तो रजिस्ट्री की सामग्री में तालिका की सामग्री जोड़ दी जाती है। यदि तालिका में पहले से ही रजिस्ट्री में समान कुंजियों के साथ ऑब्जेक्ट हैं, तो रजिस्ट्री ऑब्जेक्ट्स को नए मानों के साथ ओवरराइट किया गया है। यदि रजिस्ट्री में ऑब्जेक्ट्स हैं जो तालिका में नहीं थे, तो वे इस ऑपरेशन से अपरिवर्तित हैं।

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

सफलता पर 0 लौटता है, अन्यथा -1

int ei_reg_setfval(reg,key,f)

प्रकार

निर्दिष्ट key और अस्थायी बिंदु मान f साथ एक कुंजी-मूल्य युग्म बनाता है। यदि कोई वस्तु पहले से ही एक ही key साथ मौजूद है, तो नया मान पुराने को बदल देता है। यदि पिछला मान एक बाइनरी या स्ट्रिंग था, तो इसे free() साथ free() किया जाता है।

  • reg वह रजिस्ट्री है जहां ऑब्जेक्ट रखा जाना है।
  • key वस्तु का नाम है।
  • f असाइन करने के लिए फ्लोटिंग पॉइंट वैल्यू है।

सफलता पर 0 लौटता है, अन्यथा -1

int ei_reg_setival(reg,key,i)

प्रकार

निर्दिष्ट key और पूर्णांक मान i साथ एक कुंजी-मूल्य युग्म बनाता है। यदि कोई वस्तु पहले से ही एक ही key साथ मौजूद है, तो नया मान पुराने को बदल देता है। यदि पिछला मान एक बाइनरी या स्ट्रिंग था, तो इसे free() साथ free() किया जाता है।

  • reg वह रजिस्ट्री है जहां ऑब्जेक्ट रखा जाना है।
  • key वस्तु का नाम है।
  • i असाइन करने के लिए पूर्णांक मान है।

सफलता पर 0 लौटता है, अन्यथा -1

int ei_reg_setpval(reg,key,p,size)

प्रकार

निर्दिष्ट key साथ एक कुंजी-मूल्य जोड़ी बनाता है जिसका "मूल्य" बाइनरी ऑब्जेक्ट p द्वारा इंगित किया गया है। यदि कोई वस्तु पहले से ही एक ही key साथ मौजूद है, तो नया मान पुराने को बदल देता है। यदि पिछला मान एक बाइनरी या स्ट्रिंग था, तो इसे free() साथ free() किया जाता है।

  • reg वह रजिस्ट्री है जहां ऑब्जेक्ट रखा जाना है।
  • key वस्तु का नाम है।
  • p बाइनरी ऑब्जेक्ट का पॉइंटर है। ऑब्जेक्ट को केवल एकल कॉल के माध्यम से malloc() या इसी तरह के फ़ंक्शन के लिए बनाया जाना चाहिए, ताकि रजिस्ट्री बाद में free() कॉल करके आवश्यक हटा सके।
  • size बाइनरी ऑब्जेक्ट की बाइट्स में लंबाई है।

सफलता पर 0 लौटता है, अन्यथा -1

int ei_reg_setsval(reg,key,s)

प्रकार

निर्दिष्ट key साथ एक कुंजी-मूल्य युग्म बनाता है जिसका "मूल्य" निर्दिष्ट स्ट्रिंग s । यदि कोई वस्तु पहले से ही एक ही key साथ मौजूद है, तो नया मान पुराने को बदल देता है। यदि पिछला मान एक बाइनरी या स्ट्रिंग था, तो इसे free() साथ free() किया जाता है।

  • reg वह रजिस्ट्री है जहां ऑब्जेक्ट रखा जाना है।
  • key वस्तु का नाम है।
  • s असाइन करने के लिए स्ट्रिंग है। स्ट्रिंग को स्वयं एक कॉल के माध्यम से malloc() या एक फ़ंक्शन के समान बनाया जाना चाहिए, ताकि रजिस्ट्री बाद में free() कॉल करके आवश्यक हो सके।

सफलता पर 0 लौटता है, अन्यथा -1

int ei_reg_setval(reg,key,flags,v,...)

प्रकार

निर्दिष्ट key साथ एक कुंजी-मूल्य जोड़ी बनाता है जिसका मूल्य v द्वारा निर्दिष्ट किया गया है। यदि कोई वस्तु पहले से ही एक ही key साथ मौजूद है, तो नया मान पुराने को बदल देता है। यदि पिछला मान एक बाइनरी या स्ट्रिंग था, तो इसे free() साथ free() किया जाता है।

  • reg वह रजिस्ट्री है जहां ऑब्जेक्ट रखा जाना है।

  • key वस्तु का नाम है।

  • flags v द्वारा निर्दिष्ट ऑब्जेक्ट के प्रकार को इंगित करते हैं। झंडे EI_INT , EI_FLT , EI_STR और EI_BIN से एक होने चाहिए, जो दर्शाता है कि v int , double , char* या void* या नहीं।

    यदि flags EI_BIN , तो पांचवें तर्क size की आवश्यकता होती है, जो v द्वारा इंगित की गई वस्तु के बाइट्स में आकार को दर्शाता है।

यदि आप रजिस्ट्री में एक मनमाना पॉइंटर स्टोर करना चाहते हैं, तो 0 size निर्दिष्ट करें। इस स्थिति में, ऑब्जेक्ट केवल ei_reg_dump() कार्रवाई द्वारा स्थानांतरित नहीं किया जाता है, केवल सूचक मान।

सफलता पर 0 लौटता है, अन्यथा -1

int ei_reg_stat(reg,key,obuf)

प्रकार

किसी वस्तु के बारे में जानकारी देता है।

  • reg ऑब्जेक्ट वाली रजिस्ट्री है।
  • key वस्तु का नाम है।
  • obuf एक ei_reg_stat संरचना का सूचक है, जिसे निम्नानुसार परिभाषित किया गया है:
struct ei_reg_stat {
  int attr;
  int size;
};

EI_INT में ऑब्जेक्ट की विशेषताओं को तार्किक या उसके प्रकार ( EI_INT , EI_FLT , EI_BIN , और EI_STR ) के रूप में संग्रहीत किया जाता है, चाहे वह विलोपन के लिए चिह्नित हो ( EI_DELET , और क्या यह अंतिम बैकअप के बाद से संशोधित किया गया है Mnesia ( EI_DIRTY )।

फ़ील्ड का size EI_STR (समाप्त करने वाली 0 सहित) और EI_BIN ऑब्जेक्ट्स, या 0 लिए EI_INT और EI_FLT को संग्रहीत करने के लिए आवश्यक बाइट्स में size इंगित करता है।

0 देता है और सफलता पर obuf को इनिशियलाइज़ obuf है, अन्यथा -1

int ei_reg_tabstat(reg,obuf)

प्रकार

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

  • reg बारे में जानकारी वापस करने के लिए रजिस्ट्री है।
  • obuf एक ei_reg_tabstat संरचना का सूचक है, जिसे निम्नानुसार परिभाषित किया गया है:
struct ei_reg_tabstat {
  int size;  
  int nelem; 
  int npos;  
  int collisions; 
};

फ़ील्ड size रजिस्ट्री में हैश पदों की संख्या को इंगित करता है। यह आपके द्वारा प्रदान की गई संख्या है, जब आपने रजिस्ट्री बनाई या अंतिम रूप से, निकटतम प्राइम संख्या तक गोल आकार दिया।

  • nelem रजिस्ट्री में संग्रहीत तत्वों की संख्या को इंगित करता है। इसमें वे ऑब्जेक्ट्स शामिल हैं जो हटाए गए हैं लेकिन शुद्ध नहीं हैं।
  • npos रजिस्ट्री में कब्जे वाले अद्वितीय पदों की संख्या को इंगित करता है।
  • collisions यह दर्शाता है कि रजिस्ट्री में कितने तत्व साझा कर रहे हैं।

सफलता पर, 0 लौटाया जाता है और तालिका के आँकड़ों को समाहित करने के लिए obuf जाता है, अन्यथा -1 लौटा दिया जाता है।