एनआईएफ लाइब्रेरी में एक एरलांग मॉड्यूल के कुछ कार्यों का मूल कार्यान्वयन होता है।
देशी कार्यान्वित किए गए फ़ंक्शंस (NIF) को कॉल करने वाले के लिए किसी भी अंतर के बिना किसी भी अन्य फ़ंक्शंस की तरह कहा जाता है।
यदि NIF लाइब्रेरी सफलतापूर्वक लोड होने से पहले फ़ंक्शन को कॉल किया जाता है, तो प्रत्येक NIF को एरलांग में एक कार्यान्वयन होना चाहिए।
इस तरह के एक स्टब कार्यान्वयन एक अपवाद फेंकने के लिए है।
लेकिन इसका उपयोग एक फॉलबैक कार्यान्वयन के रूप में भी किया जा सकता है यदि एनआईएफ लाइब्रेरी को कुछ वास्तुकला के लिए लागू नहीं किया गया है।
एक बार लोड होने के बाद, एक NIF लाइब्रेरी लगातार बनी रहती है।
यह तब तक अनलोड नहीं किया जाएगा जब तक कि मॉड्यूल कोड संस्करण जो कि शुद्ध न हो।
NIF कोड और Erlang रनटाइम सिस्टम के बीच सभी इंटरैक्शन NIF API फ़ंक्शन को कॉल करके किया जाता है।
निम्नलिखित कार्यक्षमता के लिए कार्य मौजूद हैं:
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
।
ध्यान दें
ERTS 7.0 (Erlang / OTP 18) से
enif_make_badarg
पहले, एनआईएफ से
रिटर्न वैल्यू वापस
करना पड़ता था।
यह आवश्यकता अब हटा दी गई है क्योंकि एनआईएफ से वापसी मूल्य को अनदेखा कर
enif_make_badarg
दिया गया है
यदि
इसे लागू किया गया है।
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
उपयोगकर्ता गाइड में देखें।
ध्यान दें
ERTS 9.0 (OTP-20.0) के बाद से, जब
term_to_binary
नोड्स के बीच
तुलना की जाती है
या
अनुक्रमित की जाती है, तो संसाधन शर्तों में एक परिभाषित व्यवहार होता है
।
-
दो संसाधन शब्द समान iff की तुलना करेंगे जब वे पास होने पर समान संसाधन ऑब्जेक्ट पॉइंटर प्राप्त करेंगे
enif_get_resource
।
-
एक संसाधन शब्द के साथ क्रमबद्ध किया जा सकता है
term_to_binary
और बाद में पूरी तरह से फिर से बनाया जा सकता है अगर संसाधन वस्तु अभी भी जीवित है जब
binary_to_term
कहा जाता है।
यदि संसाधन ऑब्जेक्ट को हटा दिया गया है तो
एक
बासी
संसाधन शब्द वापस कर दिया जाएगा
binary_to_term
।
enif_get_resource
बासी संसाधन शर्तों के लिए गलत वापस आएगा।
धारावाहिक के समान सिद्धांत लागू होते हैं जब संदेशों में संसाधन की शर्तें दूरस्थ नोड्स और फिर से वापस जाती हैं।
एक संसाधन शब्द नोड को छोड़कर सभी नोड्स पर बासी कार्य करेगा जहां इसकी संसाधन वस्तु अभी भी स्मृति में जीवित है।
ERTS 9.0 (OTP-20.0) से पहले, सभी संसाधन शर्तों ने एक दूसरे के बराबर और बायनेरिज़ (
<<>>
)
खाली करने के लिए तुलना की थी
।
यदि सीरियल किया जाता है, तो उन्हें सादे खाली बायनेरिज़ के रूप में फिर से बनाया जाएगा।
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
कॉलबैक वापस आ गया है।
एक संसाधन में कई ईवेंट ऑब्जेक्ट हो सकते हैं लेकिन एक ईवेंट ऑब्जेक्ट केवल एक संसाधन के भीतर ही हो सकता है।
एक संसाधन तब तक नष्ट नहीं किया जाएगा जब तक कि उसके सभी निहित संबंध भंग न हो जाएं।
ध्यान दें
इरलांग प्रक्रियाओं को विफल करने का पता लगाने के लिए
enif_monitor_process
एक साथ
उपयोग करें
enif_select
और संसाधनों के स्थायी रिसाव और उनके निहित ओएस घटना वस्तुओं को पैदा करने से रोकें।
सफलता पर एक गैर-नकारात्मक मान लौटाता है, जहां निम्नलिखित बिट्स सेट किए जा सकते हैं:
-
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
शब्द की प्रतिलिपि बनाई गई है और मूल शब्द और उसका वातावरण कॉल के बाद भी मान्य है।
यह फ़ंक्शन केवल थ्रेड-सुरक्षित है जब एसएमपी समर्थन वाले एमुलेटर का उपयोग किया जाता है।
इसका उपयोग केवल गैर-एसएमपी एमुलेटर में एनआईएफ-कॉलिंग थ्रेड से किया जा सकता है।
ध्यान दें
msg_env
जैसा
NULL
कि
पासिंग
केवल ERTS 8.0 (Erlang / OTP 19) से समर्थित है।
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
पंजीकृत प्रक्रियाओं को हल करने
के
लिए
देखें
।