Erlang 21

zlib


erlang

zlib

मॉड्यूल

zlib

मॉड्यूल सारांश

zlib संपीड़न इंटरफ़ेस।

विवरण

यह मॉड्यूल zlib लाइब्रेरी ( www.zlib.net ) के लिए एक एपीआई प्रदान करता है। इसका उपयोग डेटा को संपीड़ित और विघटित करने के लिए किया जाता है। डेटा प्रारूप RFC 1950 , RFC 1951 और RFC 1952 द्वारा वर्णित है।

एक विशिष्ट (संपीड़ित) उपयोग इस प्रकार है: 

Z = zlib:open(),
ok = zlib:deflateInit(Z,default),

Compress = fun(end_of_data, _Cont) -> [];
              (Data, Cont) ->
                 [zlib:deflate(Z, Data)|Cont(Read(),Cont)]
           end,
Compressed = Compress(Read(),Compress),
Last = zlib:deflate(Z, [], finish),
ok = zlib:deflateEnd(Z),
zlib:close(Z),
list_to_binary([Compressed|Last])

सभी फ़ंक्शन त्रुटियों में, {'EXIT',{Reason,Backtrace}} को फेंका जा सकता है, जहां Reason त्रुटि का वर्णन करता है।

विशिष्ट Reasons :

badarg
बुरा तर्क।
not_initialized
स्ट्रीम को इनिशियलाइज़ नहीं किया गया है, जैसे। अगर inflateInit/1 को कॉल करने से पहले inflateInit/1 नहीं गया था।
not_on_controlling_process
धारा का उपयोग एक प्रक्रिया द्वारा किया गया था जो इसे नियंत्रित नहीं करता है। यदि आपको किसी भिन्न प्रक्रिया में एक स्ट्रीम स्थानांतरित करने की आवश्यकता है, तो set_controlling_process/2 उपयोग करें।
data_error
डेटा में त्रुटियाँ हैं।
stream_error
असंगत धारा की अवस्था।
{need_dictionary,Adler32}
inflate/2 देखें।

जानकारी का प्रकार

zstream() = reference()

एक zlib धारा, open/0 देखें।

zlevel() =
none | default | best_compression | best_speed | 0..9
zflush() = none | sync | full | finish
zmemlevel() = 1..9
zmethod() = deflated
zstrategy() = default | filtered | huffman_only | rle
zwindowbits() = -15..-8 | 8..47

आम तौर पर रेंज में -15..-8 | 8..15 -15..-8 | 8..15 ।

निर्यात

adler32 (Z, डेटा) -> चेकसम

प्रकार

Data लिए एडलर -32 चेकसम की गणना करता है।

चेतावनी

यह फ़ंक्शन हटा दिया गया है और भविष्य में रिलीज़ में हटा दिया जाएगा। erlang:adler32/1 उपयोग करें erlang:adler32/1 इसके बजाय erlang:adler32/1 ।

adler32 (Z, PrevAdler, Data) -> चेकसम

प्रकार

Data लिए चल रहे एडलर -32 चेकसम को अपडेट करता है। यदि Data खाली बाइनरी या खाली आयोलिस्ट है, तो यह फ़ंक्शन चेकसम के लिए आवश्यक प्रारंभिक मान लौटाता है।

उदाहरण: 

Crc = lists:foldl(fun(Data,Crc0) ->
                      zlib:adler32(Z, Crc0, Data),
                  end, zlib:adler32(Z,<< >>), Datas)
चेतावनी

यह फ़ंक्शन हटा दिया गया है और भविष्य में रिलीज़ में हटा दिया जाएगा। erlang:adler32/2 उपयोग करें erlang:adler32/2 इसके बजाय erlang:adler32/2 ।

adler32_combine (Z, Adler1, Adler2, Size2) -> एडलर

प्रकार

दो एडलर -32 चेकसम को एक में मिला देता है। दो बायनेरी या आईओलिस्ट्स के लिए, Size1 और Size2 Size1 और Size2 के साथ, एडलर -32 चेकसम एडलर Adler1 और एडलर 2 के साथ।

यह फ़ंक्शन केवल Adler1 , Adler2 और Size2 आवश्यकता के लिए [Data1,Data2] का Adler चेकसम Size2 ।

चेतावनी

यह फ़ंक्शन हटा दिया गया है और भविष्य में रिलीज़ में हटा दिया जाएगा। erlang:adler32_combine/3 उपयोग करें erlang:adler32_combine/3 इसके बजाय erlang:adler32_combine/3 ।

बंद (Z) -> ठीक है

प्रकार

Z द्वारा संदर्भित धारा को बंद करता है।

संपीड़ित (डेटा) -> संपीड़ित

प्रकार

Zlib हेडर और चेकसम के साथ डेटा को संपीड़ित करता है।

crc32 (Z) -> सीआरसी

प्रकार

वर्तमान गणना सीआरसी चेकसम प्राप्त करता है।

चेतावनी

यह फ़ंक्शन हटा दिया गया है और भविष्य में रिलीज़ में हटा दिया जाएगा। erlang:crc32/1 उपयोग करें erlang:crc32/1 इसके बजाय असम्पीडित डेटा पर erlang:crc32/1 ।

crc32 (Z, डेटा) -> CRC

प्रकार

Data लिए सीआरसी चेकसम की गणना करता है।

चेतावनी

यह फ़ंक्शन हटा दिया गया है और भविष्य में रिलीज़ में हटा दिया जाएगा। उपयोग erlang:crc32/1 बजाय।

crc32 (Z, PrevCRC, डेटा) -> CRC

प्रकार

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

उदाहरण: 

Crc = lists:foldl(fun(Data,Crc0) ->
                      zlib:crc32(Z, Crc0, Data),
                  end, zlib:crc32(Z,<< >>), Datas)
चेतावनी

यह फ़ंक्शन हटा दिया गया है और भविष्य में रिलीज़ में हटा दिया जाएगा। उपयोग erlang:crc32/2 बजाय।

crc32_combine (Z, CRC1, CRC2, Size2) -> CRC

प्रकार

दो CRC चेकसम को एक में जोड़ता है। दो बायनेरिज़ या आईओलिस्ट्स के लिए, डेटा 1 और Data2 और Data2 के आकार के साथ, सीआरसी चेकसम सीआरसी CRC1 और सीआरसी 2 के साथ।

यह फ़ंक्शन CRC चेकसम [Data1,Data2] CRC1 , केवल CRC1 , CRC2 और Size2 आवश्यकता होती है।

चेतावनी

यह फ़ंक्शन हटा दिया गया है और भविष्य में रिलीज़ में हटा दिया जाएगा। उपयोग erlang:crc32_combine/3 बजाय।

अपस्फीति (Z, डेटा) -> संपीड़ित

प्रकार

अपस्फीति के रूप में भी deflate(Z, Data, none) ।

अपस्फीति (Z, डेटा, फ्लश) -> संपीड़ित

प्रकार

जितना संभव हो उतना डेटा संपीड़ित करता है, और इनपुट बफर खाली होने पर बंद हो जाता है। जब फ्लश के लिए मजबूर किया जाए तो यह कुछ आउटपुट लेटेंसी (बिना किसी आउटपुट को पढ़े इनपुट) पेश कर सकता है।

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

यदि Flush को full सेट किया गया है, तो सभी आउटपुट को sync साथ फ्लश किया जाता है, और संपीड़न स्थिति को रीसेट किया जाता है, ताकि विघटन इस बिंदु से फिर से शुरू हो सके यदि पिछले संपीड़ित डेटा क्षतिग्रस्त हो गया है या यदि यादृच्छिक एक्सेस वांछित है। full का उपयोग करना अक्सर संपीड़न को गंभीरता से कम कर सकता है।

यदि Flush finish करने के लिए सेट किया गया है, तो लंबित इनपुट पर कार्रवाई की जाती है, लंबित आउटपुट को फ्लश किया जाता है, और deflate/3 रिटर्न deflate/3 जाता है। बाद में धारा पर केवल संभव संचालन deflateReset/1 या deflateEnd/1 ।

Flush को deflateInit तुरंत बाद finish करने के लिए सेट किया जा सकता है यदि सभी संपीड़न एक चरण में किया जाना है।

उदाहरण: 

zlib:deflateInit(Z),
B1 = zlib:deflate(Z,Data),
B2 = zlib:deflate(Z,<< >>,finish),
zlib:deflateEnd(Z),
list_to_binary([B1,B2])
deflateEnd (Z) -> ठीक है

प्रकार

समाप्त सत्र समाप्त होता है और उपयोग किए गए सभी डेटा को साफ करता है। ध्यान दें कि यह फ़ंक्शन एक data_error अपवाद को फेंकता है यदि अंतिम कॉल data_error deflate/3 को Flush सेट के साथ finish करने के लिए नहीं बुलाया गया था।

deflateInit (Z) -> ठीक है

प्रकार

zlib:deflateInit(Z, default) समान zlib:deflateInit(Z, default) ।

deflateInit (Z, Level) -> ठीक है

प्रकार

संपीड़न के लिए एक zlib स्ट्रीम आरंभ करता है।

Level जाने वाले संपीड़न स्तर को तय करता है:

  • 0 ( none ), कोई संपीड़न नहीं देता है
  • 1 ( best_speed ) सर्वश्रेष्ठ गति देता है
  • 9 ( best_compression ) सर्वश्रेष्ठ संपीड़न देता है
deflateInit (Z, Level, Method, WindowBits, MemLevel, Strategy) ->
ठीक

प्रकार

संपीड़न के लिए एक zlib स्ट्रीम आरंभ करता है।

Level

उपयोग करने के लिए संपीड़न स्तर:

  • 0 ( none ), कोई संपीड़न नहीं देता है
  • 1 ( best_speed ) सर्वश्रेष्ठ गति देता है
  • 9 ( best_compression ) सर्वश्रेष्ठ संपीड़न देता है
Method

उपयोग करने के लिए संपीड़न विधि, वर्तमान में एकमात्र समर्थित विधि deflated ।

WindowBits

खिड़की के आकार (इतिहास बफर के आकार) का आधार दो लघुगणक। यह 15. के माध्यम से सीमा 8 में होना है। बड़े मूल्यों में मेमोरी उपयोग की कीमत पर बेहतर संपीड़न होता है। यदि deflateInit/2 का उपयोग किया जाता है तो deflateInit/2 15 एक नकारात्मक WindowBits मान स्ट्रीम से zlib हैडर (और चेकसम) को दबा देता है। ध्यान दें कि zlib स्रोत केवल एक अनिर्दिष्ट सुविधा के रूप में इसका उल्लेख करता है।

चेतावनी

अंतर्निहित zlib लाइब्रेरी में एक ज्ञात बग के कारण, WindowBits मान 8 और -8 अपेक्षित रूप से काम नहीं करता है। 1.2.9 मानों से पहले zlib संस्करणों में 8 और -8 स्वचालित रूप से 9 और -9 में बदल जाते हैं। Zlib संस्करण से 1.2.9 मूल्य -8 को zlib:deflateInit/6 कारण अस्वीकार कर दिया गया zlib:deflateInit/6 को विफल करने के लिए (8 अभी भी 9 में बदल गया है)। यह भी संभव है कि भविष्य के संस्करण zlib इस बग को ठीक कर सकते हैं और 8 और -8 को स्वीकार करना शुरू कर सकते हैं।

निष्कर्ष: मानों से बचें 8 और -8 जब तक आप नहीं जानते कि आपका zlib संस्करण उनका समर्थन करता है।

MemLevel

निर्दिष्ट करता है कि आंतरिक संपीड़न स्थिति के लिए कितनी मेमोरी आवंटित की जानी है: MemLevel = 1 न्यूनतम मेमोरी का उपयोग करता है, लेकिन धीमा है और संपीड़न अनुपात को कम करता है; MemLevel = 9 अधिकतम गति के लिए अधिकतम मेमोरी का उपयोग करता है। 8 से चूक।

Strategy

संपीड़न एल्गोरिथ्म ट्यून। निम्नलिखित मूल्यों का उपयोग करें:

  • सामान्य डेटा के लिए default
  • filtered द्वारा उत्पादित डेटा (या पूर्वसूचक) के लिए फ़िल्टर किया गया
  • huffman_only केवल Huffman एन्कोडिंग को बल huffman_only लिए (कोई स्ट्रिंग मिलान नहीं)
  • मैच दूरी को एक तक सीमित करने के लिए rle (रन-लंबाई एन्कोडिंग)

फ़िल्टर किए गए डेटा में कुछ हद तक यादृच्छिक वितरण के साथ अधिकतर छोटे मूल्य होते हैं। इस मामले में, संपीड़न एल्गोरिथ्म उन्हें बेहतर संपीड़ित करने के लिए तैयार है। filtered का प्रभाव अधिक हफ़मैन कोडिंग और कम स्ट्रिंग मिलान के लिए मजबूर करना है; यह default और huffman_only बीच कुछ मध्यवर्ती है। rle को rle रूप में लगभग तेज़ होने के लिए डिज़ाइन किया गया है, लेकिन PNG छवि डेटा के लिए बेहतर संपीड़न देता है।

Strategy केवल संपीड़न अनुपात को प्रभावित करती है, लेकिन संपीड़ित आउटपुट की शुद्धता नहीं है, भले ही इसे उचित रूप से सेट न किया गया हो।

deflateParams (Z, Level, Strategy) -> ठीक है

प्रकार

गतिशील रूप से संपीड़न स्तर और संपीड़न रणनीति को अद्यतन करता है। Level और Strategy की व्याख्या deflateInit/6 । इसका उपयोग संपीड़न और इनपुट डेटा की सीधी प्रतिलिपि के बीच स्विच करने के लिए किया जा सकता है, या एक अलग तरह की इनपुट डेटा पर स्विच करने के लिए एक अलग रणनीति की आवश्यकता होती है। यदि संपीड़न स्तर को बदल दिया जाता है, तो अब तक उपलब्ध इनपुट पुराने स्तर के साथ संकुचित है (और फ्लश किया जा सकता है); नया स्तर केवल deflate/3 के अगले कॉल पर प्रभावी होता है।

deflateParams की कॉल से पहले, धारा स्थिति को deflateParams deflate/3 कॉल के रूप में सेट किया जाना चाहिए, क्योंकि वर्तमान में उपलब्ध इनपुट को संपीड़ित और फ्लश करना पड़ सकता है।

deflateReset (Z) -> ठीक है

प्रकार

deflateEnd/1 समतुल्य और उसके बाद deflateInit , लेकिन सभी आंतरिक संपीड़न स्थिति को मुक्त और पुनः deflateInit नहीं करता है। धारा एक ही संपीड़न स्तर और किसी भी अन्य विशेषताओं को बनाए रखती है।

deflateSetDictionary (जेड, शब्दकोश) -> Adler32

प्रकार

किसी भी संपीड़ित उत्पादन का उत्पादन किए बिना निर्दिष्ट बाइट अनुक्रम से संपीड़न शब्दकोश को प्रारंभ करता है।

deflateReset/1 किसी भी कॉल से पहले इस फ़ंक्शन को deflateInit या deflateReset/1 तुरंत बाद बुलाया जाना चाहिए।

कंप्रेसर और डीकंप्रेसर को एक ही शब्दकोश का उपयोग करना होगा (देखें inflateSetDictionary/2 )।

शब्दकोश का एडलर चेकसम वापस आ गया है।

getBufSize (Z) -> पूर्णांक ()> = 0

प्रकार

मध्यवर्ती बफर का आकार प्राप्त करता है।

चेतावनी

यह फ़ंक्शन हटा दिया गया है और भविष्य में रिलीज़ में हटा दिया जाएगा।

gunzip (डेटा) -> विघटित

प्रकार

Gz हेडर और चेकसम के साथ डेटा को अनकम्प्रेस्ड करता है।

gzip (डेटा) -> संपीड़ित

प्रकार

जीजी हेडर और चेकसम के साथ डेटा को संपीड़ित करता है।

फुलाया (जेड, डेटा) -> विघटित

प्रकार

inflate(Z, Data, []) बराबर inflate(Z, Data, [])

फुलाया (जेड, डेटा, विकल्प) -> विघटित

प्रकार

जितना संभव हो उतना डेटा घटाएं। यह कुछ आउटपुट लेटेंसी (किसी आउटपुट के उत्पादन के बिना इनपुट पढ़ना) को पेश कर सकता है।

वर्तमान में एकमात्र उपलब्ध विकल्प {exception_on_need_dict,boolean()} जो यह नियंत्रित करता है कि फ़ंक्शन को एक अपवाद फेंकना चाहिए जब एक पूर्व निर्धारित शब्दकोश को विघटन के लिए आवश्यक है। जब इसे गलत पर सेट किया जाता है, तो इसके बजाय एक need_dictionary टपल लौटाया जाएगा। विवरण के लिए inflateSetDictionary/2 देखें।

चेतावनी

यह विकल्प पश्चगामी अनुकूलता के लिए true को परिभाषित करता है, लेकिन हम भविष्य के रिलीज़ में अपवाद व्यवहार को हटाने का इरादा रखते हैं। नए कोड जिन्हें मैन्युअल रूप से शब्दकोशों को संभालने की आवश्यकता है उन्हें हमेशा {exception_on_need_dict,false} निर्दिष्ट करना चाहिए।

inflateChunk (Z) -> विघटित | {अधिक, विघटित}

प्रकार

चेतावनी

यह फ़ंक्शन हटा दिया गया है और भविष्य में रिलीज़ में हटा दिया जाएगा। इसके बजाय safeInflate/2 उपयोग करें।

असंपीड़ित डेटा का अगला हिस्सा पढ़ता है, inflateChunk/2 द्वारा आरंभ किया inflateChunk/2 ।

इस फ़ंक्शन को बार-बार कहा जाना है, जबकि यह {more, Decompressed} लौटाता है।

inflateChunk (जेड, डेटा) -> विघटित | {अधिक, विघटित}

प्रकार

चेतावनी

यह फ़ंक्शन हटा दिया गया है और भविष्य में रिलीज़ में हटा दिया जाएगा। इसके बजाय safeInflate/2 उपयोग करें।

setBufSize/2 तरह, लेकिन इससे अधिक डेटा setBufSize/2 होता है जो setBufSize/2 माध्यम से कॉन्फ़िगर किए गए बफर में फिट होगा। उच्च संपीड़न अनुपात के साथ एक धारा को विघटित करने पर उपयोगी होता है, जैसे कि संपीड़ित इनपुट की एक छोटी राशि 1000 गुना तक बढ़ सकती है।

यह फ़ंक्शन {more, Decompressed} लौटता है, जब अधिक आउटपुट उपलब्ध होता है, और इसे पढ़ने के लिए inflateChunk/1 का उपयोग किया जाना है।

यह फ़ंक्शन कुछ आउटपुट विलंबता (किसी भी आउटपुट का उत्पादन किए बिना इनपुट पढ़ना) को पेश कर सकता है।

यदि एक पर्चे शब्दकोश आगे विघटन के लिए आवश्यक है, तो एक अपवाद को फेंक दिया जाएगा। विवरण के लिए inflateSetDictionary/2 देखें।

उदाहरण: 

walk(Compressed, Handler) ->
    Z = zlib:open(),
    zlib:inflateInit(Z),
    % Limit single uncompressed chunk size to 512kb
    zlib:setBufSize(Z, 512 * 1024),
    loop(Z, Handler, zlib:inflateChunk(Z, Compressed)),
    zlib:inflateEnd(Z),
    zlib:close(Z).

loop(Z, Handler, {more, Uncompressed}) ->
    Handler(Uncompressed),
    loop(Z, Handler, zlib:inflateChunk(Z));
loop(Z, Handler, Uncompressed) ->
    Handler(Uncompressed).
inflateEnd (Z) -> ठीक है

प्रकार

फुलाते सत्र को समाप्त करता है और उपयोग किए गए सभी डेटा को साफ करता है। ध्यान दें कि यदि स्ट्रीम का कोई अंत नहीं मिला था, तो यह फ़ंक्शन data_error अपवाद को फेंकता है (जिसका अर्थ है कि सभी डेटा असम्पीडित नहीं हैं)।

inflateGetDictionary (Z) -> शब्दकोश

प्रकार

वर्तमान में स्ट्रीम द्वारा उपयोग किए जाने वाले विघटन शब्दकोश को वापस करता है। इस फ़ंक्शन को inflateInit/1 और inflateEnd बीच कहा जाना चाहिए।

केवल तभी समर्थित है जब ERTS को zlib> = 1.2.8 से संकलित किया गया था।

inflateInit (Z) -> ठीक है

प्रकार

विघटन के लिए एक ज़्लिब स्ट्रीम शुरू करता है।

inflateInit (Z, WindowBits) -> ठीक है

प्रकार

Zlib स्ट्रीम पर एक विघटन सत्र शुरू करता है।

WindowBits अधिकतम विंडो आकार (इतिहास बफर का आकार) का आधार दो लघुगणक है। यह 5 से 8 के बीच की सीमा में होना है। 15 से डिफ़ॉल्ट अगर inflateInit/1 का उपयोग किया जाता है।

यदि एक बड़े विंडो आकार के साथ एक संपीड़ित धारा इनपुट के रूप में निर्दिष्ट की जाती है, तो data_error अपवाद को inflate/2 फेंकता है।

एक नकारात्मक WindowBits मान zlib स्ट्रीम से zlib हेडर (और चेकसम) को अनदेखा करता है। ध्यान दें कि zlib स्रोत केवल एक अनिर्दिष्ट सुविधा के रूप में इसका उल्लेख करता है।

inflateReset (Z) -> ठीक है

प्रकार

inflateEnd बराबर और उसके बाद inflateEnd बराबर है, लेकिन सभी आंतरिक अपघटन अवस्था को मुक्त और पुनः उत्पन्न नहीं करता है। धारा उन विशेषताओं को बनाए inflateInit/1,2 जो inflateInit/1,2 द्वारा सेट की जा सकती inflateInit/1,2 ।

inflateSetDictionary (जेड, शब्दकोश) -> ठीक है

प्रकार

निर्दिष्ट असम्पीडित बाइट अनुक्रम से विघटन शब्दकोश को प्रारंभ करता है। इस फ़ंक्शन को एक फुलाए हुए ऑपरेशन की प्रतिक्रिया के रूप में कहा जाना चाहिए (जैसे। safeInflate/2 ) {need_dictionary,Adler,Output} या वापस किए गए कार्यों के मामले में, {'EXIT',{{need_dictionary,Adler},_StackTrace}} अपवाद।

कंप्रेसर द्वारा चुने गए शब्दकोश को एडलर मान से लौटाया जा सकता है या कॉल द्वारा फुलाया गया कार्य। कंप्रेसर और डीकंप्रेसर को एक ही शब्दकोश का उपयोग करना होगा (देखें deflateSetDictionary/2 )।

डिक्शनरी सेट करने के बाद इनफ्लो ऑपरेशन को नए इनपुट के बिना वापस लेना चाहिए।

उदाहरण: 

deprecated_unpack(Z, Compressed, Dict) ->
     case catch zlib:inflate(Z, Compressed) of
          {'EXIT',{{need_dictionary,_DictID},_}} ->
                 ok = zlib:inflateSetDictionary(Z, Dict),
                 Uncompressed = zlib:inflate(Z, []);
          Uncompressed ->
                 Uncompressed
     end.

new_unpack(Z, Compressed, Dict) ->
    case zlib:inflate(Z, Compressed, [{exception_on_need_dict, false}]) of
        {need_dictionary, _DictId, Output} ->
            ok = zlib:inflateSetDictionary(Z, Dict),
            [Output | zlib:inflate(Z, [])];
        Uncompressed ->
            Uncompressed
    end.
खुला () -> zstream()

एक zlib धारा खोलता है।

safeInflate (Z, Data) -> परिणाम

प्रकार

inflate/2 , लेकिन एक बार लागू होने के बाद यह एक छोटे कार्यान्वयन-परिभाषित सीमा से आगे बढ़ जाता है। यह तब उपयोगी होता है जब अविश्वासित इनपुट को विघटित किया जा सकता है जो सिस्टम के मेमोरी से बाहर चलने तक विस्तार करने के लिए दुर्भावनापूर्ण रूप से तैयार किया जा सकता है।

यह फ़ंक्शन देता है {continue | finished, Output} {continue | finished, Output} , जहां आउटपुट वह डेटा है जो इस कॉल में विघटित था। यदि वांछित है तो प्रत्येक इनपुट पर नए इनपुट को कतारबद्ध किया जा सकता है, और सभी पंक्तिबद्ध डेटा विघटित हो जाने पर फ़ंक्शन {finished, Output} वापस आ जाएगा।

यह फ़ंक्शन कुछ आउटपुट विलंबता (किसी भी आउटपुट का उत्पादन किए बिना इनपुट पढ़ना) को पेश कर सकता है।

यदि आगे विघटन के लिए एक पूर्व निर्धारित शब्दकोश की आवश्यकता होती है, तो यह फ़ंक्शन एक need_dictionary tuple देता है। विवरण के लिए inflateSetDictionary/2 ) देखें।

उदाहरण: 

walk(Compressed, Handler) ->
    Z = zlib:open(),
    zlib:inflateInit(Z),
    loop(Z, Handler, zlib:safeInflate(Z, Compressed)),
    zlib:inflateEnd(Z),
    zlib:close(Z).

loop(Z, Handler, {continue, Output}) ->
    Handler(Output),
    loop(Z, Handler, zlib:safeInflate(Z, []));
loop(Z, Handler, {finished, Output}) ->
    Handler(Output).
setBufSize (Z, आकार) -> ठीक है

प्रकार

मध्यवर्ती बफर आकार सेट करता है।

चेतावनी

यह फ़ंक्शन हटा दिया गया है और भविष्य में रिलीज़ में हटा दिया जाएगा।

set_controlling_process (Z, Pid) -> ठीक है

प्रकार

Z की नियंत्रण प्रक्रिया को Pid , जो एक स्थानीय प्रक्रिया होनी चाहिए।

अनकम्प्रेस्ड (डेटा) -> डिकम्प्रेस्ड

प्रकार

Zlib हेडर और चेकसम के साथ डेटा को अनकम्प्रेस करता है।

अनज़िप (डेटा) -> विघटित

प्रकार

Zlib हेडर और चेकसम के बिना डेटा को अनलॉक करता है।

zip (डेटा) -> संपीड़ित

प्रकार

Zlib हेडर और चेकसम के बिना डेटा को संपीड़ित करता है।