void *enif_alloc(size_t size)

size बाइट्स की स्मृति आवंटित करता है।

आवंटन विफल होने पर NULL लौटाता NULL ।

लौटे हुए पॉइंटर को किसी भी अंतर्निहित प्रकार के लिए उपयुक्त रूप से संरेखित किया गया है जो आवंटित मेमोरी में फिट होता है।

int enif_alloc_binary(size_t size, ErlNifBinary* bin)

आकार size बाइट्स का एक नया बाइनरी आवंटित करता है। आवंटित बाइनरी को संदर्भित करने के लिए bin द्वारा इंगित की गई संरचना को आरम्भ करता है। बाइनरी को या तो enif_release_binary द्वारा जारी किया जाना चाहिए या enif_release_binary साथ एक Erlang पद पर स्थानांतरित किया जाना चाहिए। एक आवंटित (और स्वामित्व वाली) ErlNifBinary को ErlNifBinary कॉल के बीच रखा जा सकता है।

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

आवंटन विफल होने पर सफलता, या false पर true लौटाता true ।

ErlNifEnv *enif_alloc_env()

एक नई प्रक्रिया-स्वतंत्र वातावरण आवंटित करता है। पर्यावरण का उपयोग ऐसे शब्दों को रखने के लिए किया जा सकता है जो किसी भी प्रक्रिया के लिए बाध्य नहीं हैं। इस तरह की शर्तों को बाद में enif_make_copy साथ प्रोसेस वातावरण में कॉपी किया जा सकता है या enif_make_copy वाले संदेश के रूप में एक प्रक्रिया में भेजा जा सकता है।

नए वातावरण के लिए सूचक लौटाता है।

void *enif_alloc_resource(ErlNifResourceType* type, unsigned size)

type और आकार size बाइट्स की स्मृति-प्रबंधित संसाधन ऑब्जेक्ट आवंटित करता है।

size_t enif_binary_to_term(ErlNifEnv *env, const unsigned char* data, size_t size, ERL_NIF_TERM *term, ErlNifBinaryToTerm opts)

एक शब्द बनाता है जो डेटा पर द्विआधारी डेटा को डिकोड करने का परिणाम है, जिसे एर्लांग बाहरी शब्द प्रारूप के अनुसार एन्कोड किया जाना चाहिए। size बाइट्स से अधिक data से नहीं पढ़े जाते हैं। तर्क opts erlang:binary_to_term/2 के दूसरे तर्क से मेल खाता है erlang:binary_to_term/2 और 0 या ERL_NIF_BIN2TERM_SAFE होना चाहिए।

सफलता पर, परिणामी शब्द को *term पर संग्रहीत करता है और पढ़ी जाने वाली बाइट्स की संख्या लौटाता है। यदि डिकोडिंग विफल हो जाती है या यदि opts अमान्य है, तो रिटर्न 0 ।

ErlNifBinaryToTerm , erlang:binary_to_term/2 और enif_term_to_binary भी देखें।

void enif_clear_env(ErlNifEnv* env)

एक वातावरण में सभी शर्तों को जोड़ता है और इसे पुन: उपयोग के लिए साफ करता है। पर्यावरण को enif_alloc_env साथ आवंटित किया जाना चाहिए।

int enif_compare(ERL_NIF_TERM lhs, ERL_NIF_TERM rhs)

एक पूर्णांक लौटाता है < 0 यदि lhs < rhs , 0 यदि lhs = rhs , और> 0 यदि lhs > rhs । एरलैंग ऑपरेटरों के अनुरूप == , /= , =< , < , >= , और > (लेकिन नहीं =:= या =/= )।

int enif_compare_monitors(const ErlNifMonitor *monitor1, const ErlNifMonitor *monitor2)

दो ErlNifMonitor तुलना करता है। जो भी कारण हो, मॉनिटर पर कुछ कृत्रिम आदेश लगाने के लिए भी इस्तेमाल किया जा सकता है।

0 अगर monitor1 और monitor2 बराबर हैं, तो < 0 अगर monitor1 < monitor2 , और> 0 अगर monitor1 > monitor2 ।

void enif_cond_broadcast(ErlNifCond *cnd)

erl_drv_cond_broadcast समान।

ErlNifCond *enif_cond_create(char *name)

erl_drv_cond_create समान।

void enif_cond_destroy(ErlNifCond *cnd)

erl_drv_cond_destroy समान।

char*enif_cond_name(ErlNifCond* cnd)

erl_drv_cond_name समान।

void enif_cond_signal(ErlNifCond *cnd)

erl_drv_cond_signal समान।

void enif_cond_wait(ErlNifCond *cnd, ErlNifMutex *mtx)

erl_drv_cond_wait समान।

int enif_consume_timeslice(ErlNifEnv *env, int percent)

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

ध्यान दें कि यह निर्धारित करने के लिए रनटाइम सिस्टम पर निर्भर है कि क्या और इस जानकारी का उपयोग कैसे किया जाए। कुछ प्लेटफार्मों पर कार्यान्वयन खपत सीपीयू समय निर्धारित करने के लिए अन्य साधनों का उपयोग कर सकते हैं। यह निर्धारित करने के लिए अनुमति दी जाती है कि क्या निर्धारित करने के लिए लंबी NIFs को अक्सर enif_consume_timeslice को कॉल करना चाहिए।

तर्क percent 1 और 100 के बीच पूर्णांक होना चाहिए। इस फ़ंक्शन को केवल एनआईएफ-कॉलिंग थ्रेड से बुलाया जाना चाहिए, और तर्क env को कॉलिंग प्रक्रिया का env होना चाहिए।

1 अगर समय समाप्त हो जाता है, तो रिटर्न 1 , अन्यथा 0 । यदि 1 लौटाया जाता है, तो एनआईएफ को उपज की प्रक्रिया के लिए जल्द से जल्द वापस लौटना होगा।

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

इस मैनुअल पृष्ठ की शुरुआत में warning पाठ भी देखें।

ErlNifTime enif_convert_time_unit(ErlNifTime val, ErlNifTimeUnit from, ErlNifTimeUnit to)

समय इकाई के संबंधित मान से समय इकाई के मान को परिवर्तित करता to । फर्श फ़ंक्शन का उपयोग करके परिणाम को गोल किया जाता है।

val

के लिए समय इकाई बदलने के लिए मूल्य।

from

val की समय इकाई।

to

लौटे मूल्य की समय इकाई।

यदि अमान्य समय इकाई तर्क के साथ कॉल किया जाता है, तो ERL_NIF_TIME_ERROR लौटाता है।

ErlNifTime और ErlNifTimeUnit भी देखें।

ERL_NIF_TERM enif_cpu_time(ErlNifEnv *)

erlang:timestamp() रूप में एक ही प्रारूप में CPU समय देता है erlang:timestamp() । सीपीयू समय वह समय होता है जब वर्तमान तार्किक सीपीयू ने अतीत में कुछ मनमाने बिंदु के बाद से निष्पादन को खर्च किया है। यदि OS इस मान को लाने का समर्थन नहीं करता है, तो enif_cpu_time आमंत्रित करता है।

int enif_demonitor_process(ErlNifEnv* env, void* obj, const ErlNifMonitor* mon)

पहले enif_monitor_process साथ बनाया गया एक मॉनिटर रद्द करता है। तर्क obj निगरानी रखने वाले संसाधन का एक संकेतक है और *mon मॉनिटर की पहचान करता है।

रिटर्न 0 अगर मॉनिटर को सफलतापूर्वक पहचान लिया गया और हटा दिया गया। यदि कोई मॉनीटर पहचाना नहीं जा सकता, तो गैर-शून्य मान देता है, जिसका अर्थ है कि यह या तो था

• इस संसाधन के लिए कभी नहीं बनाया गया
• पहले ही रद्द कर दिया गया
• पहले से ही ट्रिगर
• बस एक समवर्ती धागे द्वारा ट्रिगर किया जाएगा

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

int enif_equal_tids(ErlNifTid tid1, ErlNifTid tid2)

erl_drv_equal_tids समान।

int enif_fprintf(FILE *stream, const char *format, ...)

fprintf समान लेकिन यह प्रारूप स्ट्रिंग "%T" भी स्वीकार करता है, जो Erlang शब्दों को प्रारूपित करता है।

यह फ़ंक्शन मूल रूप से डीबगिंग उद्देश्य के लिए इरादा था। इसके साथ बहुत बड़ी शर्तें मुद्रित करने की अनुशंसा नहीं की जाती है %T । समारोह errno सफल होने पर भी बदल सकता है ।

void enif_free(void* ptr)

द्वारा आवंटित की गई मेमोरी मेमोरी enif_alloc ।

void enif_free_env(ErlNifEnv* env)

एक पर्यावरण के साथ आवंटित पर्यावरण enif_alloc_env । वातावरण में निर्मित सभी शर्तों को भी मुक्त कर दिया जाता है।

void enif_free_iovec(ErlNifIOvec* iov)

पेड़ एक io वेक्टर से लौटे enif_inspect_iovec() । यह तभी आवश्यक है जब NULL पर्यावरण को पारित किया जाए enif_inspect_iovec() ।

ErlNifIOVec *iovec = NULL;
size_t max_elements = 128;
ERL_NIF_TERM tail;
if (!enif_inspect_iovec(NULL, max_elements, term, &tail, &iovec))
  return 0;

// Do things with the iovec

/* Free the iovector, possibly in another thread or nif function call */
enif_free_iovec(iovec);

int enif_get_atom(ErlNifEnv* env, ERL_NIF_TERM term, char* buf, unsigned size, ErlNifCharEncoding encode)

एन्कोडिंग के साथ परमाणु के स्ट्रिंग प्रतिनिधित्व से मिलकर, आकार NULL द्वारा इंगित बफर में एक -स्ट्रिंग स्ट्रिंग लिखता है । buf size term encode

लिखित बाइट्स की संख्या लौटाता है ( NULL वर्ण समाप्त करने सहित ) या 0 यदि term अधिकतम लंबाई वाला परमाणु नहीं है size-1 ।

int enif_get_atom_length(ErlNifEnv* env, ERL_NIF_TERM term, unsigned* len, ErlNifCharEncoding encode)

एन्कोडिंग के साथ परमाणु *len की लंबाई (बाइट्स को समाप्त करने वाले NULL वर्ण को छोड़कर ) पर सेट करता है । term encode

रिटर्न true सफलता पर, या false अगर term एक परमाणु नहीं है।

int enif_get_double(ErlNifEnv* env, ERL_NIF_TERM term, double* dp)

*dp के फ़्लोटिंग-पॉइंट मान पर सेट करता है term ।

true सफलता पर रिटर्न , या false अगर term एक फ्लोट नहीं है।

int enif_get_int(ErlNifEnv* env, ERL_NIF_TERM term, int* ip)

*ip के पूर्णांक मान पर सेट करता है term ।

true सफलता पर रिटर्न , या false यदि term पूर्णांक नहीं है या प्रकार की सीमा के बाहर है int ।

int enif_get_int64(ErlNifEnv* env, ERL_NIF_TERM term, ErlNifSInt64* ip)

*ip के पूर्णांक मान पर सेट करता है term ।

true सफलता पर रिटर्न , या false यदि term एक पूर्णांक नहीं है या एक हस्ताक्षरित 64-बिट पूर्णांक की सीमा के बाहर है।

int enif_get_local_pid(ErlNifEnv* env, ERL_NIF_TERM term, ErlNifPid* pid)

यदि term एक नोड स्थानीय प्रक्रिया का pid है, तो यह फ़ंक्शन *pid इसमें से pid वैरिएबल को इनिशियलाइज़ करता है और लौटता है true । अन्यथा false लौट आता false । यह देखने के लिए कोई जाँच नहीं की जाती है कि क्या यह प्रक्रिया जीवित है।

int enif_get_local_port(ErlNifEnv* env, ERL_NIF_TERM term, ErlNifPort* port_id)

यदि term एक नोड स्थानीय पोर्ट की पहचान करता है, तो यह फ़ंक्शन पोर्ट चर *port_id को इससे आरंभ करता है और वापस लौटता है true । अन्यथा false लौट आता false । यह देखने के लिए कोई जाँच नहीं की जाती है कि पोर्ट जीवित है या नहीं।

int enif_get_list_cell(ErlNifEnv* env, ERL_NIF_TERM list, ERL_NIF_TERM* head, ERL_NIF_TERM* tail)

सेट *head और *tail सूची से list ।

true सफलता पर रिटर्न , या false अगर यह सूची नहीं है या सूची खाली है।

int enif_get_list_length(ErlNifEnv* env, ERL_NIF_TERM term, unsigned* len)

*len सूची की लंबाई के लिए सेट term ।

true सफलता पर रिटर्न , या false यदि term एक उचित सूची नहीं है।

int enif_get_long(ErlNifEnv* env, ERL_NIF_TERM term, long int* ip)

*ip के लंबे पूर्णांक मान पर सेट होता है term ।

true सफलता पर रिटर्न , या false यदि term पूर्णांक नहीं है या प्रकार की सीमा के बाहर है long int ।

int enif_get_map_size(ErlNifEnv* env, ERL_NIF_TERM term, size_t *size)

*size नक्शे में कुंजी-मूल्य जोड़े की संख्या के लिए सेट term ।

true सफलता पर लौटा , या false अगर term एक नक्शा नहीं है।

int enif_get_map_value(ErlNifEnv* env, ERL_NIF_TERM map, ERL_NIF_TERM key, ERL_NIF_TERM* value)

मानचित्र में *value संबद्ध मान पर सेट करता है । key map

true सफलता पर वापसी करता है, या false यदि map कोई नक्शा नहीं है या यदि map नहीं है key ।

int enif_get_resource(ErlNifEnv* env, ERL_NIF_TERM term, ErlNifResourceType* type, void** objp)

*objp द्वारा संदर्भित संसाधन ऑब्जेक्ट को इंगित करने के लिए सेट करता है term ।

रिटर्न true सफलता पर, या false अगर term प्रकार का एक संसाधन ऑब्जेक्ट में एक संभाल नहीं है type ।

int enif_get_string(ErlNifEnv* env, ERL_NIF_TERM list, char* buf, unsigned size, ErlNifCharEncoding encode)

एक NULL स्ट्रिंग में वर्णों से मिलकर, buf आकार के द्वारा इंगित बफर में स्ट्रिंग लिखता है । वर्ण एन्कोडिंग का उपयोग करके लिखे गए हैं । size list encode

निम्न में से एक लौटाता है:

• लिखित बाइट्स की संख्या ( NULL वर्ण समाप्त करने सहित )
• -size यदि बफर स्थान की वजह से तार काट दिया गया था
• 0 यदि list वह स्ट्रिंग नहीं है जिसे साथ एन्कोड किया जा सकता है encode या यदि size <था 1 ।

NULL जब तक बफ़र size < नहीं लिखा जाता है , तब तक लिखित स्ट्रिंग हमेशा- नियंत्रित होती है 1 ।

int enif_get_tuple(ErlNifEnv* env, ERL_NIF_TERM term, int* arity, const ERL_NIF_TERM** array)

यदि term एक ट्यूपल है, तो यह फ़ंक्शन *array एक सरणी को इंगित करता है जिसमें टपल के तत्व हैं, और *arity तत्वों की संख्या पर सेट है। ध्यान दें कि सरणी केवल-पढ़ने (*array)[N-1] के लिए है और टपल का Nth तत्व है। *array टडले की धमनी शून्य होने पर अपरिभाषित होती है।

रिटर्न true सफलता पर, या false अगर term एक टपल नहीं है।

int enif_get_uint(ErlNifEnv* env, ERL_NIF_TERM term, unsigned int* ip)

*ip के अहस्ताक्षरित पूर्णांक मान पर सेट करता है term ।

true सफलता पर रिटर्न , या false अगर term एक अहस्ताक्षरित पूर्णांक नहीं है या प्रकार की सीमा के बाहर है unsigned int ।

int enif_get_uint64(ErlNifEnv* env, ERL_NIF_TERM term, ErlNifUInt64* ip)

*ip के अहस्ताक्षरित पूर्णांक मान पर सेट करता है term ।

true सफलता पर रिटर्न , या false अगर term एक अहस्ताक्षरित पूर्णांक नहीं है या एक अहस्ताक्षरित 64-बिट पूर्णांक की सीमा के बाहर है।

int enif_get_ulong(ErlNifEnv* env, ERL_NIF_TERM term, unsigned long* ip)

*ip के अहस्ताक्षरित लंबे पूर्णांक मान पर सेट करता है term ।

true सफलता पर रिटर्न , या false अगर term एक अहस्ताक्षरित पूर्णांक नहीं है या प्रकार की सीमा के बाहर है unsigned long ।

int enif_getenv(const char* key, char* value, size_t *value_size)

के रूप में ही erl_drv_getenv ।

int enif_has_pending_exception(ErlNifEnv* env, ERL_NIF_TERM* reason)

true यदि एक लंबित अपवाद पर्यावरण के साथ जुड़ा हुआ है, तो लौटाता है env । यदि reason कोई NULL सूचक है, तो इसे अनदेखा करें। अन्यथा, यदि कोई लंबित अपवाद env मौजूद है, *reason तो अपवाद शब्द के मान पर सेट करें। उदाहरण के लिए, यदि enif_make_badarg लंबित badarg अपवाद सेट करने के लिए कहा जाता है , तो परमाणु को enif_has_pending_exception(env, &reason) सेट *reason करने के लिए बाद में कॉल किया जाता है badarg , फिर वापस लौटें true ।

यह भी देखें enif_make_badarg और enif_raise_exception ।

ErlNifUInt64 enif_hash(ErlNifHash type, ERL_NIF_TERM term, ErlNifUInt64 salt)

term निर्दिष्ट के अनुसार हैश ErlNifHash type ।

लिया नमक की रेंज (यदि कोई हो) और लौटाया गया मूल्य हैश प्रकार पर निर्भर करता है।

int enif_inspect_binary(ErlNifEnv* env, ERL_NIF_TERM bin_term, ErlNifBinary* bin)

bin द्विआधारी शब्द के बारे में जानकारी के साथ द्वारा बताई गई संरचना को प्रारंभ करता है bin_term ।

true सफलता पर रिटर्न , या false अगर bin_term एक बाइनरी नहीं है।

int enif_inspect_iolist_as_binary(ErlNifEnv* env, ERL_NIF_TERM term, ErlNifBinary* bin)

के bin रूप में एक ही बाइट सामग्री के साथ एक सतत बफ़र द्वारा इंगित संरचना को प्रारंभ करता है iolist । जैसा कि inspect_binary , बताया गया डेटा bin क्षणिक है और इसे जारी करने की आवश्यकता नहीं है।

रिटर्न true सफलता पर, या false अगर iolist एक iolist नहीं है।

int enif_inspect_iovec(ErlNifEnv* env, size_t max_elements, ERL_NIF_TERM iovec_term, ERL_NIF_TERM* tail, ErlNifIOVec** iovec)

iovec में प्रदान की गई बायनेरिज़ की सूची के साथ भरता है iovec_term । कॉल में संभाले गए तत्वों की संख्या सीमित है max_elements , और tail सूची के शेष पर सेट है। ध्यान दें कि आउटपुट max_elements कुछ प्लेटफार्मों पर की तुलना में अधिक लंबा हो सकता है।

एक मनमाने आयोलिस्ट से बायनेरिज़ की सूची बनाने के लिए, उपयोग करें erlang:iolist_to_iovec/1 ।

इस फ़ंक्शन को कॉल करते समय, iovec एक पॉइंटर NULL या एक ErlNifIOVec संरचना को शामिल करना चाहिए जिसे यदि संभव हो तो उपयोग किया जाना चाहिए। जैसे

/* Don't use a pre-allocated structure */
ErlNifIOVec *iovec = NULL;
enif_inspect_iovec(env, max_elements, term, &tail, &iovec);

/* Use a stack-allocated vector as an optimization for vectors with few elements */
ErlNifIOVec vec, *iovec = &vec;
enif_inspect_iovec(env, max_elements, term, &tail, &iovec);

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

true सफलता पर वापसी , या नहीं false तो iovec_term iovec।

ErlNifIOQueue *enif_ioq_create(ErlNifIOQueueOpts opts)

एक नया I / O कतार बनाएं जिसका उपयोग डेटा संग्रहीत करने के लिए किया जा सकता है। opts के लिए सेट किया जाना है ERL_NIF_IOQ_NORMAL ।

void enif_ioq_destroy(ErlNifIOQueue *q)

I / O कतार को नष्ट करें और इसे सभी सामग्री से मुक्त करें

int enif_ioq_deq(ErlNifIOQueue *q, size_t count, size_t *size)

count I / O कतार से डीक्यू बाइट्स। यदि size नहीं NULL , तो कतार का नया आकार वहां रखा गया है।

true सफलता पर रिटर्न , या false अगर I / O में count बाइट्स नहीं हैं । असफल होने पर कतार को बिना बदले छोड़ दिया जाता है।

int enif_ioq_enq_binary(ErlNifIOQueue *q, ErlNifBinary *bin, size_t skip)

Enqueue bin में q पहले लंघन skip बाइट्स।

रिटर्न true सफलता पर, या false यदि skip का आकार से अधिक है bin । बाइनरी डेटा के किसी भी स्वामित्व को कतार में स्थानांतरित bin किया जाता है और इसे केवल एनआईएफ के बाकी कॉल के लिए और फिर जारी किए जाने के लिए केवल पढ़ने के लिए माना जाता है।

int enif_ioq_enqv(ErlNifIOQueue *q, ErlNifIOVec *iovec, size_t skip)

Enqueue iovec में q पहले लंघन skip बाइट्स।

रिटर्न true सफलता पर, या false यदि skip का आकार से अधिक है iovec ।

SysIOVec *enif_ioq_peek(ErlNifIOQueue *q, int *iovlen)

I / O कतार को सूचक के रूप में प्राप्त करें SysIOVec । यह तत्वों की संख्या भी लौटाता है iovlen ।

इस फ़ंक्शन द्वारा कतार से कुछ भी नहीं निकाला जाता है, जिसे इसके साथ किया जाना चाहिए enif_ioq_deq() ।

लौटे सरणी यूनिक्स सिस्टम कॉल के साथ उपयोग करने के लिए उपयुक्त है writev ।

int enif_ioq_peek_head(ErlNifEnv *env, ErlNifIOQueue *q, size_t *size, ERL_NIF_TERM *bin_term)

एक द्विआधारी शब्द के रूप में IO कतार का प्रमुख प्राप्त करें।

यदि size नहीं है NULL , तो सिर का आकार वहां रखा गया है।

इस फ़ंक्शन द्वारा कतार से कुछ भी नहीं निकाला जाता है, जिसे इसके साथ किया जाना चाहिए enif_ioq_deq() ।

रिटर्न true सफलता पर, या false कतार खाली है यदि।

size_t enif_ioq_size(ErlNifIOQueue *q)

का आकार प्राप्त करें q ।

int enif_is_atom(ErlNifEnv* env, ERL_NIF_TERM term)

रिटर्न true अगर term एक परमाणु है।

int enif_is_binary(ErlNifEnv* env, ERL_NIF_TERM term)

true अगर term बाइनरी है तो रिटर्न करता है।

int enif_is_current_process_alive(ErlNifEnv* env)

true यदि वर्तमान में निष्पादित प्रक्रिया वर्तमान में जीवित है, तो वापस लौटाता है, अन्यथा false ।

यह फ़ंक्शन केवल एनआईएफ-कॉलिंग थ्रेड से और वर्तमान में निष्पादित प्रक्रियाओं के अनुरूप वातावरण के साथ उपयोग किया जा सकता है।

int enif_is_empty_list(ErlNifEnv* env, ERL_NIF_TERM term)

true यदि term रिक्त सूची है, तो लौटाता है।

int enif_is_exception(ErlNifEnv* env, ERL_NIF_TERM term)

अगर term अपवाद है तो सच्चा लौटें ।

int enif_is_fun(ErlNifEnv* env, ERL_NIF_TERM term)

रिटर्न true अगर term एक मजेदार है।

int enif_is_identical(ERL_NIF_TERM lhs, ERL_NIF_TERM rhs)

true यदि दो शब्द समान हैं तो लौटाता है । Erlang ऑपरेटरों के अनुरूप है =:= और =/= ।

int enif_is_list(ErlNifEnv* env, ERL_NIF_TERM term)

true यदि term सूची है तो लौटाता है।

int enif_is_map(ErlNifEnv* env, ERL_NIF_TERM term)

true अगर term नक्शा है, तो वापस कर दें false ।

int enif_is_number(ErlNifEnv* env, ERL_NIF_TERM term)

true अगर term एक नंबर है तो लौटाता है।

int enif_is_pid(ErlNifEnv* env, ERL_NIF_TERM term)

रिटर्न true अगर term एक पीआईडी ​​है।

int enif_is_port(ErlNifEnv* env, ERL_NIF_TERM term)

पोर्ट है true तो लौटाता term है।

int enif_is_port_alive(ErlNifEnv* env, ErlNifPort *port_id)

रिटर्न true अगर port_id जीवित है।

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

int enif_is_process_alive(ErlNifEnv* env, ErlNifPid *pid)

रिटर्न true अगर pid जीवित है।

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

int enif_is_ref(ErlNifEnv* env, ERL_NIF_TERM term)

true यदि term संदर्भ है तो लौटाता है।

int enif_is_tuple(ErlNifEnv* env, ERL_NIF_TERM term)

लौटता है true तो term टपल।

int enif_keep_resource(void* obj)

obj से प्राप्त संसाधन ऑब्जेक्ट का संदर्भ जोड़ता है enif_alloc_resource । ऑब्जेक्ट को नष्ट enif_keep_resource करने enif_release_resource से पहले प्रत्येक कॉल किसी ऑब्जेक्ट के लिए संतुलित होनी चाहिए ।

ERL_NIF_TERM enif_make_atom(ErlNifEnv* env, const char* name)

आईएसओ लैटिन -1 एन्कोडिंग के साथ NULL -terminated C-string से एक परमाणु शब्द बनाता है name । यदि name एक परमाणु (255 वर्ण) के लिए अनुमत अधिकतम लंबाई से अधिक है, तो enif_make_atom आक्रमण होता है enif_make_badarg ।

ERL_NIF_TERM enif_make_atom_len(ErlNifEnv* env, const char* name, size_t len)

name लंबाई के साथ स्ट्रिंग से एक परमाणु शब्द बनाएं len । NULL पात्रों को किसी भी अन्य पात्रों के रूप में माना जाता है। यदि len एक परमाणु (255 वर्ण) के लिए अनुमत अधिकतम लंबाई से अधिक है, तो enif_make_atom आह्वान करता है enif_make_badarg ।

ERL_NIF_TERM enif_make_badarg(ErlNifEnv* env)

badarg एक NIF से लौटाया जाने वाला एक अपवाद बनाता है , और इसे पर्यावरण के साथ जोड़ता है env । एक बार एनआईएफ या किसी भी फ़ंक्शन को यह आह्वान करता है enif_make_badarg , रनटाइम सुनिश्चित करता है कि badarg एनआईएफ वापस आने पर एक अपवाद उठाया जाता है, भले ही एनआईएफ इसके बजाय एक गैर-अपवाद शब्द वापस करने का प्रयास करता है।

से वापसी मूल्य का enif_make_badarg उपयोग केवल उस एनआईएफ से वापसी मूल्य के रूप में किया जा सकता है जिसने इसे (प्रत्यक्ष या अप्रत्यक्ष रूप से) लागू किया है या पास किया जा सकता है enif_is_exception , लेकिन किसी अन्य एनआईएफ एपीआई फ़ंक्शन को नहीं।

यह भी देखें enif_has_pending_exception और enif_raise_exception ।

ERL_NIF_TERM enif_make_binary(ErlNifEnv* env, ErlNifBinary* bin)

से एक द्विआधारी शब्द बनाता है bin । बाइनरी डेटा का कोई भी स्वामित्व निर्मित शब्द में स्थानांतरित bin किया जाता है और इसे केवल एनआईएफ के बाकी कॉल के लिए और फिर जारी किए जाने के लिए केवल पढ़ने के लिए माना जाता है।

ERL_NIF_TERM enif_make_copy(ErlNifEnv* dst_env, ERL_NIF_TERM src_term)

शब्द की एक प्रति बनाता है src_term । कॉपी पर्यावरण में बनाई गई है dst_env । स्रोत शब्द किसी भी वातावरण में स्थित हो सकता है।

ERL_NIF_TERM enif_make_double(ErlNifEnv* env, double d)

एक से एक अस्थायी बिंदु शब्द बनाता है double । यदि तर्क double परिमित नहीं है या NaN है, तो enif_make_double आह्वान करता है enif_make_badarg ।

int enif_make_existing_atom(ErlNifEnv* env, const char* name, ERL_NIF_TERM* atom, ErlNifCharEncoding encode)

एन्कोडिंग के साथ NULL -terminated C-string से पहले से मौजूद परमाणु का शब्द बनाने की कोशिश करता है । name encode

यदि परमाणु पहले से मौजूद है, तो यह फ़ंक्शन शब्द को *atom वापस संग्रहीत करता है और true अन्यथा false । false यदि name परमाणु (255 वर्ण) के लिए अनुमत अधिकतम लंबाई से अधिक है, तो भी रिटर्न ।

int enif_make_existing_atom_len(ErlNifEnv* env, const char* name, size_t len, ERL_NIF_TERM* atom, ErlNifCharEncoding encoding)

name लंबाई len और एन्कोडिंग के साथ स्ट्रिंग से पहले से मौजूद परमाणु का कार्यकाल बनाने की कोशिश करता है encode । NULL पात्रों को किसी भी अन्य पात्रों के रूप में माना जाता है।

यदि परमाणु पहले से मौजूद है, तो यह फ़ंक्शन शब्द को *atom वापस संग्रहीत करता है और true अन्यथा false । false यदि len परमाणु (255 वर्ण) के लिए अनुमत अधिकतम लंबाई से अधिक है तो भी वापस आ जाता है।

ERL_NIF_TERM enif_make_int(ErlNifEnv* env, int i)

पूर्णांक शब्द बनाता है।

ERL_NIF_TERM enif_make_int64(ErlNifEnv* env, ErlNifSInt64 i)

हस्ताक्षरित 64-बिट पूर्णांक से पूर्णांक शब्द बनाता है।

ERL_NIF_TERM enif_make_list(ErlNifEnv* env, unsigned cnt, ...)

लंबाई की एक साधारण सूची शब्द बनाता है cnt । उम्मीद है cnt (के बाद तर्क की संख्या cnt प्रकार के) ERL_NIF_TERM सूची के तत्वों के रूप।

खाली सूची देता है यदि cnt 0 है।

ERL_NIF_TERM enif_make_list1(ErlNifEnv* env, ERL_NIF_TERM e1) ERL_NIF_TERM enif_make_list2(ErlNifEnv* env, ERL_NIF_TERM e1, ERL_NIF_TERM e2) ERL_NIF_TERM enif_make_list3(ErlNifEnv* env, ERL_NIF_TERM e1, ERL_NIF_TERM e2, ERL_NIF_TERM e3) ERL_NIF_TERM enif_make_list4(ErlNifEnv* env, ERL_NIF_TERM e1, ..., ERL_NIF_TERM e4) ERL_NIF_TERM enif_make_list5(ErlNifEnv* env, ERL_NIF_TERM e1, ..., ERL_NIF_TERM e5) ERL_NIF_TERM enif_make_list6(ErlNifEnv* env, ERL_NIF_TERM e1, ..., ERL_NIF_TERM e6) ERL_NIF_TERM enif_make_list7(ErlNifEnv* env, ERL_NIF_TERM e1, ..., ERL_NIF_TERM e7) ERL_NIF_TERM enif_make_list8(ErlNifEnv* env, ERL_NIF_TERM e1, ..., ERL_NIF_TERM e8) ERL_NIF_TERM enif_make_list9(ErlNifEnv* env, ERL_NIF_TERM e1, ..., ERL_NIF_TERM e9)

फ़ंक्शन नाम द्वारा इंगित लंबाई के साथ एक सामान्य सूची शब्द बनाता है। enif_make_list यदि तर्कों की संख्या मेल नहीं खाती है, तो संकलन-समय त्रुटि प्राप्त करने के लिए वैरेडिक पर इन कार्यों (मैक्रोज़) को प्राथमिकता दें

ERL_NIF_TERM enif_make_list_cell(ErlNifEnv* env, ERL_NIF_TERM head, ERL_NIF_TERM tail)

एक सूची सेल बनाता है [head | tail] ।

ERL_NIF_TERM enif_make_list_from_array(ErlNifEnv* env, const ERL_NIF_TERM arr[], unsigned cnt)

arr लंबाई की सरणी के तत्वों से युक्त एक सामान्य सूची बनाता है cnt ।

खाली सूची देता है यदि cnt 0 है।

ERL_NIF_TERM enif_make_long(ErlNifEnv* env, long int i)

से एक पूर्णांक शब्द बनाता है long int ।

int enif_make_map_put(ErlNifEnv* env, ERL_NIF_TERM map_in, ERL_NIF_TERM key, ERL_NIF_TERM value, ERL_NIF_TERM* map_out)

नक्शे की एक प्रति बनाता है map_in और key साथ सम्मिलित करता है value । यदि key पहले से मौजूद है map_in , तो पुराने संबद्ध मान को बदल दिया जाता है value ।

सफल होने पर, यह फ़ंक्शन *map_out नए मानचित्र पर सेट होता है और वापस लौटता है true । false अगर map_in नक्शा नहीं है तो लौटाता है।

यह map_in शब्द पर्यावरण से संबंधित होना चाहिए env ।

int enif_make_map_remove(ErlNifEnv* env, ERL_NIF_TERM map_in, ERL_NIF_TERM key, ERL_NIF_TERM* map_out)

नक्शा तो map_in शामिल key है, इस समारोह की एक प्रतिलिपि बनाता map_in में *map_out , और निकालता है key और संबद्ध मूल्य। यदि नक्शा map_in शामिल नहीं है key , *map_out तो सेट किया गया है map_in ।

true सफलता पर लौटा , या false अगर map_in एक नक्शा नहीं है।

यह map_in शब्द पर्यावरण से संबंधित होना चाहिए env ।

int enif_make_map_update(ErlNifEnv* env, ERL_NIF_TERM map_in, ERL_NIF_TERM key, ERL_NIF_TERM new_value, ERL_NIF_TERM* map_out)

नक्शे की एक प्रति बनाता है map_in और पुराने संबद्ध मान को बदल देता key है new_value ।

सफल होने पर, यह फ़ंक्शन *map_out नए मानचित्र पर सेट होता है और वापस लौटता है true । false अगर map_in नक्शा नहीं है या नहीं है तो लौटाता है key ।

यह map_in शब्द पर्यावरण से संबंधित होना चाहिए env ।

int enif_make_map_from_arrays(ErlNifEnv* env, ERL_NIF_TERM keys[], ERL_NIF_TERM values[], size_t cnt, ERL_NIF_TERM *map_out)

दिए गए कुंजी और मूल्यों से एक नक्शा शब्द बनाता है।

सफल होने पर, यह फ़ंक्शन *map_out नए मानचित्र पर सेट होता है और वापस लौटता है true । रिटर्न false वहाँ किसी भी डुप्लिकेट चाबियाँ हैं।

सभी कुंजियों और मूल्यों से संबंधित होना चाहिए env ।

unsigned char *enif_make_new_binary(ErlNifEnv* env, size_t size, ERL_NIF_TERM* termp)

आकार size बाइट्स का एक बाइनरी आवंटित करता है और एक मालिकाना शब्द बनाता है। जब तक NIF कॉलिंग न हो तब तक बाइनरी डेटा म्यूट होता है। यह उपयोग किए बिना एक नया बाइनरी बनाने का एक त्वरित तरीका है ErlNifBinary । कमियां यह हैं कि द्विआधारी को NIF कॉल के बीच नहीं रखा जा सकता है और इसे पुनः प्राप्त नहीं किया जा सकता।

कच्चे बाइनरी डेटा को एक पॉइंटर लौटाता है और *termp बाइनरी टर्म पर सेट करता है।

ERL_NIF_TERM enif_make_new_map(ErlNifEnv* env)

खाली नक्शा शब्द बनाता है।

ERL_NIF_TERM enif_make_pid(ErlNifEnv* env, const ErlNifPid* pid)

से एक कठिन शब्द बनाता है *pid ।

ERL_NIF_TERM enif_make_ref(ErlNifEnv* env)

जैसा कोई संदर्भ बनाता है erlang:make_ref/0 ।

ERL_NIF_TERM enif_make_resource(ErlNifEnv* env, void* obj)

द्वारा प्राप्त स्मृति-प्रबंधित संसाधन ऑब्जेक्ट में एक अपारदर्शी हैंडल बनाता है enif_alloc_resource । कोई स्वामित्व हस्तांतरण नहीं किया जाता है, क्योंकि संसाधन ऑब्जेक्ट को अभी भी जारी करने की आवश्यकता है enif_release_resource । हालाँकि, ध्यान दें कि कॉल enif_release_resource शब्द से प्राप्त करने के तुरंत बाद हो सकता है enif_make_resource , जिस स्थिति में शब्द एकत्र होने पर संसाधन ऑब्जेक्ट को हटा दिया जाता है। अधिक जानकारी के लिए, example of creating and returning a resource object उपयोगकर्ता गाइड में देखें।

ERL_NIF_TERM enif_make_resource_binary(ErlNifEnv* env, void* obj, const void* data, size_t size)

एक द्विआधारी शब्द बनाता है जिसे मेमोरी द्वारा प्रबंधित संसाधन ऑब्जेक्ट द्वारा प्रबंधित obj किया जाता है enif_alloc_resource । दिए गए बाइनरी शब्द में size बाइट्स की ओर इशारा किया गया है data । इस कच्चे बाइनरी डेटा को पठनीय और अपरिवर्तित रखा जाना चाहिए जब तक कि संसाधन का विनाशकर्ता नहीं कहा जाता है। बाइनरी डेटा को संसाधन ऑब्जेक्ट के लिए बाहरी संग्रहीत किया जा सकता है, जिस स्थिति में डेटा को जारी करने के लिए विध्वंसक जिम्मेदार है।

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

जैसा कि enif_make_resource , कोई स्वामित्व हस्तांतरण नहीं किया जाता है। संसाधन को अभी भी जारी करने की आवश्यकता है enif_release_resource ।

int enif_make_reverse_list(ErlNifEnv* env, ERL_NIF_TERM list_in, ERL_NIF_TERM *list_out)

सेट *list_out सूची के पीछे की सूची पर list_in और रिटर्न true , या रिटर्न false अगर list_in एक सूची नहीं है।

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

यह list_in शब्द पर्यावरण से संबंधित होना चाहिए env ।

ERL_NIF_TERM enif_make_string(ErlNifEnv* env, const char* string, ErlNifCharEncoding encoding)

एन्कोडिंग के साथ NULL -terminated स्ट्रिंग के वर्णों वाली सूची बनाता है । string encode

ERL_NIF_TERM enif_make_string_len(ErlNifEnv* env, const char* string, size_t len, ErlNifCharEncoding encoding)

एक सूची बनाता है जिसमें string लंबाई len और एन्कोडिंग के साथ स्ट्रिंग के वर्ण होते हैं encode । NULL पात्रों को किसी भी अन्य पात्रों के रूप में माना जाता है।

ERL_NIF_TERM enif_make_sub_binary(ErlNifEnv* env, ERL_NIF_TERM bin_term, size_t pos, size_t size)

बाइट्स की एक उप-श्रृंखला बनाता है bin_term , जो बाइट्स की pos लंबाई के साथ शून्य-आधारित स्थिति पर शुरू होता है size । bin_term बाइनरी या बिटस्ट्रिंग होना चाहिए। pos+size में कम या पूरे बाइट्स की संख्या के बराबर होना चाहिए bin_term ।

ERL_NIF_TERM enif_make_tuple(ErlNifEnv* env, unsigned cnt, ...)

तुच्छ शब्द का निर्माण करता है cnt । उम्मीद है cnt (के बाद तर्क की संख्या cnt प्रकार के) ERL_NIF_TERM टपल के तत्वों के रूप।

ERL_NIF_TERM enif_make_tuple1(ErlNifEnv* env, ERL_NIF_TERM e1) ERL_NIF_TERM enif_make_tuple2(ErlNifEnv* env, ERL_NIF_TERM e1, ERL_NIF_TERM e2) ERL_NIF_TERM enif_make_tuple3(ErlNifEnv* env, ERL_NIF_TERM e1, ERL_NIF_TERM e2, ERL_NIF_TERM e3) ERL_NIF_TERM enif_make_tuple4(ErlNifEnv* env, ERL_NIF_TERM e1, ..., ERL_NIF_TERM e4) ERL_NIF_TERM enif_make_tuple5(ErlNifEnv* env, ERL_NIF_TERM e1, ..., ERL_NIF_TERM e5) ERL_NIF_TERM enif_make_tuple6(ErlNifEnv* env, ERL_NIF_TERM e1, ..., ERL_NIF_TERM e6) ERL_NIF_TERM enif_make_tuple7(ErlNifEnv* env, ERL_NIF_TERM e1, ..., ERL_NIF_TERM e7) ERL_NIF_TERM enif_make_tuple8(ErlNifEnv* env, ERL_NIF_TERM e1, ..., ERL_NIF_TERM e8) ERL_NIF_TERM enif_make_tuple9(ErlNifEnv* env, ERL_NIF_TERM e1, ..., ERL_NIF_TERM e9)

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

ERL_NIF_TERM enif_make_tuple_from_array(ErlNifEnv* env, const ERL_NIF_TERM arr[], unsigned cnt)

arr लंबाई के सरणी के तत्वों वाले एक टपल बनाता है cnt ।

ERL_NIF_TERM enif_make_uint(ErlNifEnv* env, unsigned int i)

से एक पूर्णांक शब्द बनाता है unsigned int ।

ERL_NIF_TERM enif_make_uint64(ErlNifEnv* env, ErlNifUInt64 i)

अहस्ताक्षरित 64-बिट पूर्णांक से पूर्णांक शब्द बनाता है।

ERL_NIF_TERM enif_make_ulong(ErlNifEnv* env, unsigned long i)

से एक पूर्णांक शब्द बनाता है unsigned long int ।

ERL_NIF_TERM enif_make_unique_integer(ErlNifEnv *env, ErlNifUniqueInteger properties)

द्वारा निर्दिष्ट के रूप में एक ही गुण के साथ एक अद्वितीय पूर्णांक देता है erlang:unique_integer/1 ।

env में पूर्णांक बनाने के लिए पर्यावरण है।

ERL_NIF_UNIQUE_POSITIVE और ERL_NIF_UNIQUE_MONOTONIC पूर्णांक के गुणों को बदलने के लिए दूसरे तर्क के रूप में पारित किया जा सकता है। उन्हें OR द्वारा संयोजित किया जा सकता है: दो मानों को एक साथ जोड़ते हैं।

यह भी देखें ErlNifUniqueInteger ।

int enif_map_iterator_create(ErlNifEnv *env, ERL_NIF_TERM map, ErlNifMapIterator *iter, ErlNifMapIteratorEntry entry)

map द्वारा इंगित संरचना को आरंम्भ करके मानचित्र के लिए एक पुनरावृत्ति बनाता है iter । तर्क इट्रेटर entry की शुरुआत की स्थिति निर्धारित करता है: ERL_NIF_MAP_ITERATOR_FIRST या ERL_NIF_MAP_ITERATOR_LAST ।

true यदि map नक्शा नहीं है , तो सफलता, या झूठ पर रिटर्न ।

एक मैप इटेटर केवल पर्यावरण के जीवनकाल के दौरान उपयोगी होता है env , जिसका map संबंध है। इटैलर को कॉल करके नष्ट किया जाना चाहिए enif_map_iterator_destroy :

ERL_NIF_TERM key, value;
ErlNifMapIterator iter;
enif_map_iterator_create(env, my_map, &iter, ERL_NIF_MAP_ITERATOR_FIRST);

while (enif_map_iterator_get_pair(env, &iter, &key, &value)) {
    do_something(key,value);
    enif_map_iterator_next(env, &iter);
}
enif_map_iterator_destroy(env, &iter);

void enif_map_iterator_destroy(ErlNifEnv *env, ErlNifMapIterator *iter)

द्वारा बनाए गए मैप इटेटर को नष्ट कर देता है enif_map_iterator_create ।

int enif_map_iterator_get_pair(ErlNifEnv *env, ErlNifMapIterator *iter, ERL_NIF_TERM *key, ERL_NIF_TERM *value)

वर्तमान मानचित्र पुनरावृत्ति स्थिति में कुंजी और मूल्य की शर्तें प्राप्त करता है।

सफलता पर, सेट *key और *value और रिटर्न true । रिटर्न false अगर इट्रेटर सिर पर (पहली प्रविष्टि से पहले) या पूंछ (अंतिम प्रविष्टि से परे) पर स्थित है।

int enif_map_iterator_is_head(ErlNifEnv *env, ErlNifMapIterator *iter)

true यदि रिटर्न इट्रेटर iter पहली प्रविष्टि से पहले तैनात है।

int enif_map_iterator_is_tail(ErlNifEnv *env, ErlNifMapIterator *iter)

true यदि iter अंतिम प्रविष्टि के बाद मैप इटेटर तैनात है तो वापस लौटाता है।

int enif_map_iterator_next(ErlNifEnv *env, ErlNifMapIterator *iter)

अगले मुख्य-मूल्य प्रविष्टि को इंगित करने के लिए इंक्रीमेंट मैप इटरेटर।

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

int enif_map_iterator_prev(ErlNifEnv *env, ErlNifMapIterator *iter)

पिछले मुख्य-मूल्य प्रविष्टि को इंगित करने के लिए Decrements मैप इटरेटर।

true यदि इट्रेटर अब एक मान्य कुंजी-मूल्य प्रविष्टि पर स्थित है, या false यदि इटिटर को हेड (पहले प्रवेश से पहले) पर स्थित है, तो वापस लौटाता है ।

int enif_monitor_process(ErlNifEnv* env, void* obj, const ErlNifPid* target_pid, ErlNifMonitor* mon)

एक संसाधन से एक प्रक्रिया की निगरानी शुरू करता है। जब एक प्रक्रिया की निगरानी की जाती है, down तो संसाधन प्रकार से जुड़े कॉलबैक को कॉल करने की प्रक्रिया में एक परिणाम से बाहर निकलता है ।

obj निगरानी रखने के लिए तर्क संसाधन का सूचक है और *target_pid स्थानीय प्रक्रिया की निगरानी करने के लिए पहचान करता है।

यदि mon ऐसा नहीं है NULL , तो एक सफल कॉल ErlNifMonitor द्वारा बताई गई संरचना में मॉनिटर की पहचान को संग्रहीत करता है mon । इस पहचानकर्ता का उपयोग बाद में हटाने enif_demonitor_process या इसके साथ तुलना करने के लिए मॉनिटर को संदर्भित करने के लिए किया जाता है enif_compare_monitors । जब यह ट्रिगर हो जाता है या जब संसाधन समाप्त हो जाता है तो एक मॉनिटर स्वचालित रूप से हटा दिया जाता है।

0 यदि कोई down कॉलबैक प्रदान नहीं किया गया है, तो सफलता पर रिटर्न , और यदि प्रक्रिया अब जीवित नहीं है, तो 0।

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

ErlNifTime enif_monotonic_time(ErlNifTimeUnit time_unit)

करंट लौटाता है Erlang monotonic time । ध्यान दें कि यह नकारात्मक मूल्यों के साथ असामान्य नहीं है।

time_unit लौटाया गया मान का समय इकाई है।

ERL_NIF_TIME_ERROR यदि कोई अमान्य समय इकाई तर्क के साथ कहा जाता है, या यदि वह थ्रेड से कॉल किया जाता है, जो कोई शेड्यूलर थ्रेड नहीं है, तो लौटाता है

यह भी देखें ErlNifTime और ErlNifTimeUnit ।

ErlNifMutex *enif_mutex_create(char *name)

के रूप में ही erl_drv_mutex_create ।

void enif_mutex_destroy(ErlNifMutex *mtx)

के रूप में ही erl_drv_mutex_destroy ।

void enif_mutex_lock(ErlNifMutex *mtx)

के रूप में ही erl_drv_mutex_lock ।

char*enif_mutex_name(ErlNifMutex* mtx)

के रूप में ही erl_drv_mutex_name ।

int enif_mutex_trylock(ErlNifMutex *mtx)

के रूप में ही erl_drv_mutex_trylock ।

void enif_mutex_unlock(ErlNifMutex *mtx)

के रूप में ही erl_drv_mutex_unlock ।

ERL_NIF_TERM enif_now_time(ErlNifEnv *env)

एक रिटर्न erlang:now() समय स्टाम्प।

इस फ़ंक्शन को पदावनत किया जाता है।

ErlNifResourceType *enif_open_resource_type(ErlNifEnv* env, const char* module_str, const char* name, ErlNifResourceDtor* dtor, ErlNifResourceFlags flags, ErlNifResourceFlags* tried)

स्ट्रिंग द्वारा पहचाने गए संसाधन प्रकार को बनाता है या लेता है name और इसे इंगित किए गए विनाशकर्ता फ़ंक्शन देता है dtor । तर्क flags में निम्नलिखित मूल्य हो सकते हैं:

ERL_NIF_RT_CREATE

एक नया संसाधन प्रकार बनाता है जो पहले से मौजूद नहीं है।

ERL_NIF_RT_TAKEOVER

एक मौजूदा संसाधन प्रकार को खोलता है और इसके सभी उदाहरणों पर स्वामित्व रखता है। आपूर्ति किए गए विनाशकर्ता dtor को मौजूदा उदाहरणों के लिए कहा जाता है और नए उदाहरणों को अभी तक कॉलिंग एनआईएफ लाइब्रेरी द्वारा नहीं बनाया गया है।

दो ध्वज मूल्यों को बिटवाइज़ या के साथ जोड़ा जा सकता है। संसाधन प्रकार का नाम कॉलिंग मॉड्यूल के लिए स्थानीय है। तर्क module_str का उपयोग नहीं किया गया है (अभी तक) और होना चाहिए NULL । dtor हो सकता है NULL अगर कोई विध्वंसक की जरूरत न हो।

सफलता पर, समारोह संसाधन प्रकार के लिए सूचक वापस आती है और *tried करने के लिए या तो सेट कर दिया जाता ERL_NIF_RT_CREATE या ERL_NIF_RT_TAKEOVER इंगित करने के लिए क्या किया गया था। विफलता पर, रिटर्न NULL और सेट *tried पर flags । इसे सेट tried करने की अनुमति है NULL ।

सूचना जो enif_open_resource_type केवल दो कॉलबैक में कॉल करने की अनुमति है load और upgrade ।

यह भी देखें enif_open_resource_type_x ।

ErlNifResourceType *enif_open_resource_type_x(ErlNifEnv* env, const char* name, const ErlNifResourceTypeInit* init, ErlNifResourceFlags flags, ErlNifResourceFlags* tried)

के रूप में ही enif_open_resource_type छोड़कर यह संसाधन प्रकार है कि के साथ एक साथ इस्तेमाल कर रहे हैं के लिए अतिरिक्त कॉलबैक कार्यों को स्वीकार करता है enif_select और enif_monitor_process ।

तर्क init एक ErlNifResourceTypeInit संरचना का सूचक है जिसमें संसाधन प्रकार के लिए विनाशकारी, डाउन और स्टॉप कॉलबैक के लिए फ़ंक्शन पॉइंटर्स होते हैं।

int enif_port_command(ErlNifEnv* env, const ErlNifPort* to_port, ErlNifEnv *msg_env, ERL_NIF_TERM msg)

के रूप में काम करता है erlang:port_command/2 , सिवाय इसके कि यह हमेशा पूरी तरह से अतुल्यकालिक है।

env

कॉलिंग प्रक्रिया का वातावरण। नहीं होना चाहिए NULL ।

*to_port

प्राप्त पोर्ट की पोर्ट आईडी। पोर्ट आईडी स्थानीय नोड पर एक पोर्ट को संदर्भित करना है।

msg_env

संदेश शब्द का वातावरण। एक प्रक्रिया स्वतंत्र पर्यावरण के साथ आवंटित किया जा सकता है enif_alloc_env या NULL ।

msg

भेजने के लिए संदेश शब्द। पेलोड पर जैसी सीमाएँ लागू होती हैं erlang:port_command/2 ।

एक का उपयोग msg_env की NULL एक अनुकूलन है, जो संगठनों को एक साथ कहता है करने के लिए enif_alloc_env , enif_make_copy , enif_port_command , और enif_free_env एक कॉल में। यह अनुकूलन केवल तभी उपयोगी होता है जब अधिकांश शर्तों को कॉपी किया जाना env हो msg_env ।

true यदि आदेश सफलतापूर्वक भेजा जाता है, तो लौटाता है । false उदाहरण के लिए, कमांड विफल होने पर लौटाता है :

• *to_port स्थानीय पोर्ट को संदर्भित नहीं करता है।
• वर्तमान में निष्पादित प्रक्रिया (जो कि प्रेषक है) जीवित नहीं है।
• msg अमान्य है।

यह भी देखें enif_get_local_port ।

void *enif_priv_data(ErlNifEnv* env)

उस निजी डेटा को सूचक लौटाता है जिसे load या द्वारा सेट किया गया था upgrade ।

ERL_NIF_TERM enif_raise_exception(ErlNifEnv* env, ERL_NIF_TERM reason)

NIF reason से लौटाए जाने वाले शब्द के साथ एक त्रुटि अपवाद बनाता है , और इसे पर्यावरण के साथ जोड़ता है env । एक बार एनआईएफ या किसी भी फ़ंक्शन को यह आह्वान करता है enif_raise_exception , रनटाइम यह सुनिश्चित करता है कि यह जो अपवाद बनाता है वह तब उठाया जाता है जब एनआईएफ लौटता है, भले ही एनआईएफ इसके बजाय एक गैर-अपवाद शब्द वापस करने का प्रयास करता है।

से वापसी मूल्य का enif_raise_exception उपयोग केवल उस एनआईएफ से वापसी मूल्य के रूप में किया जा सकता है जिसने इसे (प्रत्यक्ष या अप्रत्यक्ष रूप से) लागू किया है या पास किया जा सकता है enif_is_exception , लेकिन किसी अन्य एनआईएफ एपीआई फ़ंक्शन को नहीं।

यह भी देखें enif_has_pending_exception और enif_make_badarg ।

void *enif_realloc(void* ptr, size_t size)

द्वारा आबंटित स्मृति से पुनर enif_alloc को size बाइट्स।

NULL यदि पुनः प्राप्ति विफल हो जाती है तो वापस लौटता है।

लौटे हुए पॉइंटर को किसी भी अंतर्निहित प्रकार के लिए उपयुक्त रूप से संरेखित किया गया है जो आवंटित मेमोरी में फिट होता है।

int enif_realloc_binary(ErlNifBinary* bin, size_t size)

एक बाइनरी का आकार बदलता है bin । स्रोत बाइनरी केवल-पढ़ा जा सकता है, जिस स्थिति में इसे अछूता छोड़ दिया जाता है और एक परस्पर प्रतिलिपि आवंटित और आवंटित की जाती है *bin ।

true सफलता पर रिटर्न , या false यदि स्मृति आवंटन विफल रहा।

void enif_release_binary(ErlNifBinary* bin)

से प्राप्त एक बाइनरी को रिहा करता है enif_alloc_binary ।

void enif_release_resource(void* obj)

obj से प्राप्त संसाधन ऑब्जेक्ट का संदर्भ निकालता है enif_alloc_resource । अंतिम संदर्भ हटाए जाने पर संसाधन ऑब्जेक्ट को नष्ट कर दिया जाता है। प्रत्येक कॉल के enif_release_resource लिए enif_alloc_resource या पिछले कॉल के अनुरूप होना चाहिए enif_keep_resource । द्वारा किए गए संदर्भ enif_make_resource केवल कचरा कलेक्टर द्वारा ही निकाले जा सकते हैं।

ErlNifRWLock *enif_rwlock_create(char *name)

के रूप में ही erl_drv_rwlock_create ।

void enif_rwlock_destroy(ErlNifRWLock *rwlck)

के रूप में ही erl_drv_rwlock_destroy ।

char*enif_rwlock_name(ErlNifRWLock* rwlck)

के रूप में ही erl_drv_rwlock_name ।

void enif_rwlock_rlock(ErlNifRWLock *rwlck)

के रूप में ही erl_drv_rwlock_rlock ।

void enif_rwlock_runlock(ErlNifRWLock *rwlck)

के रूप में ही erl_drv_rwlock_runlock ।

void enif_rwlock_rwlock(ErlNifRWLock *rwlck)

के रूप में ही erl_drv_rwlock_rwlock ।

void enif_rwlock_rwunlock(ErlNifRWLock *rwlck)

के रूप में ही erl_drv_rwlock_rwunlock ।

int enif_rwlock_tryrlock(ErlNifRWLock *rwlck)

के रूप में ही erl_drv_rwlock_tryrlock ।

int enif_rwlock_tryrwlock(ErlNifRWLock *rwlck)

के रूप में ही erl_drv_rwlock_tryrwlock ।

ERL_NIF_TERM enif_schedule_nif(ErlNifEnv* env, const char* fun_name, int flags, ERL_NIF_TERM (*fp)(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]), int argc, const ERL_NIF_TERM argv[])

अनुसूचियां fp निष्पादित करने के लिए एनआईएफ । यह फ़ंक्शन एक एप्लिकेशन को कई नियमित एनआईएफ कॉल में लंबे समय तक चलने वाले काम को तोड़ने या dirty NIF गंदे शेड्यूलर थ्रेड पर निष्पादित करने की अनुमति देता है ।

fun_name

NIF के लिए एक नाम प्रदान करता है जो निष्पादन के लिए निर्धारित है। यदि इसे एक परमाणु में परिवर्तित नहीं किया जा सकता है, तो enif_schedule_nif एक badarg अपवाद देता है।

flags

0 एक नियमित एनआईएफ के लिए निर्धारित किया जाना चाहिए । यदि एम्यूलेटर को गंदे शेड्यूलर समर्थन सक्षम के साथ बनाया गया था, flags तो या ERL_NIF_DIRTY_JOB_CPU_BOUND तो यह निर्धारित किया जा सकता है कि क्या नौकरी सीपीयू-बाउंड होने की उम्मीद है, या ERL_NIF_DIRTY_JOB_IO_BOUND उन नौकरियों के लिए जो I / O-बाध्य होंगे। यदि गंदे शेड्यूलर थ्रेड्स एमुलेटर में उपलब्ध नहीं हैं, तो इस तरह के काम के परिणाम को शेड्यूल करने का प्रयास notsup अपवाद है।

argc तथा argv

क्या मूल को कॉलिंग NIF में पारित किया जा सकता है, या कॉलिंग NIF द्वारा बनाए गए मान हो सकते हैं।

कॉलिंग NIF enif_schedule_nif को अपने स्वयं के रिटर्न मान के रूप में वापसी मूल्य का उपयोग करना चाहिए ।

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

int enif_select(ErlNifEnv* env, ErlNifEvent event, enum ErlNifSelectFlags mode, void* obj, const ErlNifPid* pid, ERL_NIF_TERM ref)

इस फ़ंक्शन का उपयोग अतुल्यकालिक सूचनाओं को प्राप्त करने के लिए किया जा सकता है जब ओएस-विशिष्ट ईवेंट ऑब्जेक्ट या तो पढ़ने या लिखने के संचालन के लिए तैयार हो जाते हैं।

तर्क event घटना वस्तु की पहचान करता है। यूनिक्स प्रणालियों पर, कार्यों select / poll का उपयोग किया जाता है। ईवेंट ऑब्जेक्ट सॉकेट, पाइप या अन्य फ़ाइल डिस्क्रिप्टर ऑब्जेक्ट होना चाहिए जो select / poll उपयोग कर सकता है।

तर्क mode घटनाओं के प्रकार का वर्णन करने के लिए प्रतीक्षा करता है। यह ERL_NIF_SELECT_READ , ERL_NIF_SELECT_WRITE या दोनों के लिए प्रतीक्षा करने के लिए एक बिटवाइज़ या संयोजन हो सकता है। यह वह भी हो सकता है ERL_NIF_SELECT_STOP जिसका वर्णन नीचे किया गया है। जब कोई पढ़ने या लिखने की घटना शुरू होती है, तो इस तरह से एक अधिसूचना संदेश द्वारा पहचानी गई प्रक्रिया को भेजा जाता है pid :

{select, Obj, Ref, ready_input | ready_output}

ready_input या ready_output इंगित करता है कि ईवेंट ऑब्जेक्ट पढ़ने या लिखने के लिए तैयार है या नहीं।

तर्क कॉलिंग प्रक्रिया को इंगित करने के लिए pid हो सकता NULL है।

तर्क obj एक संसाधन से प्राप्त वस्तु है enif_alloc_resource । संसाधन ऑब्जेक्ट का उद्देश्य इवेंट ऑब्जेक्ट के एक कंटेनर के रूप में अपने राज्य और जीवनकाल का प्रबंधन करने के लिए है। सूचना संदेश के रूप में संसाधन का एक हैंडल प्राप्त होता है Obj ।

तर्क ref या तो एक संदर्भ होना चाहिए या erlang:make_ref/0 परमाणु से प्राप्त किया जाना चाहिए undefined । इसे Ref नोटिफिकेशन में पास किया जाएगा । यदि receive अधिसूचना के लिए प्रतीक्षा करने के लिए एक चयनात्मक बयान का उपयोग किया जाता है, तो receive एक रनटाइम ऑप्टिमाइज़ेशन का उपयोग करने से ठीक पहले बनाया गया एक संदर्भ जो कतार में सभी पहले प्राप्त संदेशों को बायपास करता है।

सूचनाएं केवल एक-शॉट हैं। एक ही प्रकार (आगे पढ़ें या लिखें) की और enif_select सूचनाएं प्राप्त करने के लिए, प्रत्येक सूचना प्राप्त करने के बाद बार-बार कॉल करना होगा।

का प्रयोग करें ERL_NIF_SELECT_STOP के रूप में mode आदेश सुरक्षित रूप से एक घटना उद्देश्य यह है कि करने के लिए पारित किया गया है बंद करने के लिए में enif_select । इवेंट ऑब्जेक्ट को बंद करने के लिए सुरक्षित होने पर stop संसाधन का कॉलबैक obj कहा जाएगा। ईवेंट ऑब्जेक्ट्स को बंद करने के इस सुरक्षित तरीके का उपयोग किया जाना चाहिए, भले ही सभी सूचनाएं प्राप्त हुई हों और आगे कॉल न की enif_select गई हो।

enif_select विशिष्ट OS के लिए पहला कॉल event इवेंट ऑब्जेक्ट और युक्त संसाधन के बीच एक संबंध स्थापित करेगा। सभी के लिए बाद में कॉल event तर्क के रूप में अपने संसाधन युक्त होना चाहिए obj । इस संबंध को तब भंग कर enif_select दिया जाता है जब इसके साथ कॉल किया mode जाता है ERL_NIF_SELECT_STOP और संबंधित stop कॉलबैक वापस आ गया है। एक संसाधन में कई ईवेंट ऑब्जेक्ट हो सकते हैं लेकिन एक ईवेंट ऑब्जेक्ट केवल एक संसाधन के भीतर ही हो सकता है। एक संसाधन तब तक नष्ट नहीं किया जाएगा जब तक कि उसके सभी निहित संबंध भंग न हो जाएं।

सफलता पर एक गैर-नकारात्मक मान लौटाता है, जहां निम्नलिखित बिट्स सेट किए जा सकते हैं:

ERL_NIF_SELECT_STOP_CALLED

स्टॉप कॉलबैक द्वारा सीधे कॉल किया गया था enif_select ।

ERL_NIF_SELECT_STOP_SCHEDULED

स्टॉप कॉलबैक को किसी अन्य थ्रेड पर या बाद में इस थ्रेड द्वारा चलाने के लिए निर्धारित किया गया था।

यदि कॉल विफल हो गया तो एक नकारात्मक मान लौटाता है जहां निम्नलिखित बिट्स सेट किए जा सकते हैं:

ERL_NIF_SELECT_INVALID_EVENT

तर्क event एक मान्य OS ईवेंट ऑब्जेक्ट नहीं है।

ERL_NIF_SELECT_FAILED

ईवेंट ऑब्जेक्ट को पोल सेट में जोड़ने के लिए सिस्टम कॉल विफल रहा।

retval = enif_select(env, fd, ERL_NIF_SELECT_STOP, resource, ref);
if (retval < 0) {
    /* handle error */
}
/* Success! */
if (retval & ERL_NIF_SELECT_STOP_CALLED) {
    /* ... */
}

ErlNifPid *enif_self(ErlNifEnv* caller_env, ErlNifPid* pid)

कॉलिंग प्रक्रिया का प्रतिनिधित्व करने के लिए ErlNifPid चर पर प्रारंभिक *pid ।

रिटर्न pid अगर सफल, या शून्य अगर caller_env एक नहीं है ErlNifEnv ।

int enif_send(ErlNifEnv* env, ErlNifPid* to_pid, ErlNifEnv* msg_env, ERL_NIF_TERM msg)

एक प्रक्रिया के लिए एक संदेश भेजता है।

env

कॉलिंग प्रक्रिया का वातावरण। NULL निर्मित धागे से कॉल करने पर ही होना चाहिए ।

*to_pid

प्राप्त करने की प्रक्रिया की पिड। Pid को स्थानीय नोड पर एक प्रक्रिया को संदर्भित करना है।

msg_env

संदेश शब्द का वातावरण। enif_alloc_env NULL या NULL के साथ आवंटित एक प्रक्रिया-स्वतंत्र वातावरण होना चाहिए ।

msg

भेजने के लिए संदेश शब्द।

true यदि संदेश सफलतापूर्वक भेजा जाता है तो वापस लौटता है । false यदि रिटर्न भेजने में विफल रहता है, तो वह है:

• *to_pid एक जीवित स्थानीय प्रक्रिया का उल्लेख नहीं करता है।
• वर्तमान में निष्पादित प्रक्रिया (जो कि प्रेषक है) जीवित नहीं है।

एक सफल कॉल द्वारा msg_env इसकी सभी शर्तों (सहित msg ) के साथ संदेश का वातावरण अमान्य है enif_send । पर्यावरण को या तो फिर से मुक्त करने enif_free_env के लिए मुक्त किया जाना है enif_clear_env ।

यदि msg_env सेट किया गया है NULL , तो msg शब्द की प्रतिलिपि बनाई गई है और मूल शब्द और उसका वातावरण कॉल के बाद भी मान्य है।

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

unsigned enif_sizeof_resource(void* obj)

obj द्वारा प्राप्त संसाधन ऑब्जेक्ट की बाइट आकार प्राप्त करता है enif_alloc_resource ।

int enif_snprintf(char *str, size_t size, const char *format, ...)

इसी तरह snprintf लेकिन यह प्रारूप स्ट्रिंग भी स्वीकार करता है "%T" , जो Erlang शब्दों को प्रारूपित करता है ।

यह फ़ंक्शन मूल रूप से डीबगिंग उद्देश्य के लिए इरादा था। इसके साथ बहुत बड़ी शर्तें मुद्रित करने की अनुशंसा नहीं की जाती है %T । समारोह errno सफल होने पर भी बदल सकता है ।

void enif_system_info(ErlNifSysInfo *sys_info_ptr, size_t size)

के रूप में ही driver_system_info ।

int enif_term_to_binary(ErlNifEnv *env, ERL_NIF_TERM term, ErlNifBinary *bin)

एर्लांग बाहरी शब्द प्रारूप के अनुसार enif_alloc_binary एन्कोडिंग के परिणाम के साथ एक नया बाइनरी आवंटित term करता है।

true सफलता पर रिटर्न , या false यदि आवंटन विफल रहता है।

यह भी देखें erlang:term_to_binary/1 और enif_binary_to_term ।

int enif_thread_create(char *name,ErlNifTid *tid,void * (*func)(void *),void *args,ErlNifThreadOpts *opts)

के रूप में ही erl_drv_thread_create ।

void enif_thread_exit(void *resp)

के रूप में ही erl_drv_thread_exit ।

int enif_thread_join(ErlNifTid, void **respp)

के रूप में ही erl_drv_thread_join ।

char*enif_thread_name(ErlNifTid tid)

के रूप में ही erl_drv_thread_name ।

ErlNifThreadOpts *enif_thread_opts_create(char *name)

के रूप में ही erl_drv_thread_opts_create ।

void enif_thread_opts_destroy(ErlNifThreadOpts *opts)

के रूप में ही erl_drv_thread_opts_destroy ।

ErlNifTid enif_thread_self(void)

के रूप में ही erl_drv_thread_self ।

int enif_thread_type(void)

वर्तमान में निष्पादित थ्रेड के प्रकार का निर्धारण करें। एक सकारात्मक मान एक शेड्यूलर थ्रेड को इंगित करता है जबकि एक नकारात्मक मान या शून्य दूसरे प्रकार के थ्रेड को इंगित करता है। वर्तमान में निम्नलिखित विशिष्ट प्रकार मौजूद हैं (जिन्हें भविष्य में बढ़ाया जा सकता है):

ERL_NIF_THR_UNDEFINED

अपरिभाषित धागा जो एक अनुसूचक धागा नहीं है।

ERL_NIF_THR_NORMAL_SCHEDULER

एक सामान्य अनुसूचक धागा।

ERL_NIF_THR_DIRTY_CPU_SCHEDULER

एक गंदा सीपीयू अनुसूचक धागा।

ERL_NIF_THR_DIRTY_IO_SCHEDULER

एक गंदा I / O अनुसूचक धागा।

ErlNifTime enif_time_offset(ErlNifTimeUnit time_unit)

वर्तमान समय को बीच में ऑफसेट करता है Erlang monotonic time और तर्क के रूप Erlang system time में परिवर्तित time_unit हो जाता है।

time_unit लौटाया गया मान का समय इकाई है।

रिटर्न ERL_NIF_TIME_ERROR गलत समय इकाई तर्क के साथ कॉल या एक धागा है कि एक अनुसूचक धागा नहीं है से कहा जाता है, तो यदि।

यह भी देखें ErlNifTime और ErlNifTimeUnit ।

void *enif_tsd_get(ErlNifTSDKey key)

के रूप में ही erl_drv_tsd_get ।

int enif_tsd_key_create(char *name, ErlNifTSDKey *key)

के रूप में ही erl_drv_tsd_key_create ।

void enif_tsd_key_destroy(ErlNifTSDKey key)

के रूप में ही erl_drv_tsd_key_destroy ।

void enif_tsd_set(ErlNifTSDKey key, void *data)

के रूप में ही erl_drv_tsd_set ।

int enif_vfprintf(FILE *stream, const char *format, va_list ap)

समतुल्य enif_fprintf सिवाय इसके कि एक के साथ अपने बुलाया va_list तर्क के परिवर्तनशील के बजाय।

int enif_vsnprintf(char *str, size_t size, const char *format, va_list ap)

समतुल्य enif_snprintf सिवाय इसके कि एक के साथ अपने बुलाया va_list तर्क के परिवर्तनशील के बजाय।

int enif_whereis_pid(ErlNifEnv *env, ERL_NIF_TERM name, ErlNifPid *pid)

एक प्रक्रिया को उसके पंजीकृत नाम से देखता है।

env

कॉलिंग प्रक्रिया का वातावरण। NULL निर्मित धागे से कॉल करने पर ही होना चाहिए ।

name

परमाणु के रूप में एक पंजीकृत प्रक्रिया का नाम।

*pid

ErlNifPid जो में हल प्रक्रिया आईडी संग्रहित है।

सफलता पर, *pid स्थानीय प्रक्रिया के साथ पंजीकृत name और रिटर्न के लिए सेट true । यदि name एक पंजीकृत प्रक्रिया नहीं है, या एक परमाणु नहीं है, false तो वापस आ गया है और *pid अपरिवर्तित है।

के रूप में काम करता है erlang:whereis/1 , लेकिन प्रक्रियाओं तक ही सीमित है। enif_whereis_port पंजीकृत बंदरगाहों को हल करने के लिए देखें ।

int enif_whereis_port(ErlNifEnv *env, ERL_NIF_TERM name, ErlNifPort *port)

इसके पंजीकृत नाम से एक बंदरगाह दिखता है।

env

कॉलिंग प्रक्रिया का वातावरण। NULL निर्मित धागे से कॉल करने पर ही होना चाहिए ।

name

परमाणु के रूप में पंजीकृत बंदरगाह का नाम।

*port

ErlNifPort जो में हल बंदरगाह आईडी संग्रहित है।

सफलता के साथ, *port पोर्ट के साथ पंजीकृत name और रिटर्न के लिए सेट true । यदि name एक पंजीकृत बंदरगाह नहीं है, या एक परमाणु नहीं है, false तो वापस लौटा दिया जाता है और *port अपरिवर्तित होता है।

के रूप में काम करता है erlang:whereis/1 , लेकिन बंदरगाहों तक ही सीमित है। enif_whereis_pid पंजीकृत प्रक्रियाओं को हल करने के लिए देखें ।