टेलीग्राफर का टेप

आप channel-chatter में स्ट्रीम का इस्तेमाल पहले ही कर चुके हैं और boatswains-bilge में उन्हें dispose भी कर चुके हैं। यह अभ्यास आपकी पहली कस्टम स्ट्रीम है, यानी एक ऐसी क्लास जो प्रोटोकॉल लागू करती है, ताकि वही with-input-stream / read1 / stream-read1 कोड जो एक <string-reader> पर काम करता था, आपकी स्ट्रीम पर भी काम करे।

मिक्सिन: क्लास पदानुक्रम का दूसरा आधा हिस्सा

आप dragons-descendants से TUPLE: child < parent … पहले ही जानते हैं। यह एक ही मूल क्लास वाला पदानुक्रम है, जिसमें स्लॉट नीचे की ओर आते हैं। Factor में क्लास ग्राफ़ बढ़ाने का दूसरा तरीका भी है: ओपन मिक्सिन। MIXIN: m बिना किसी स्लॉट वाली एक क्लास घोषित करता है; बाद में दूसरी क्लासें INSTANCE: c m लिखकर उसमें शामिल हो सकती हैं। सदस्यता कई-से-कई होती है: एक क्लास जितने चाहे मिक्सिन की इंस्टेंस बन सकती है।

स्ट्रीम प्रोटोकॉल दो मिक्सिन इस्तेमाल करता है, ताकि पता चले कि कोई क्लास इंटरफ़ेस का कौन-सा आधा हिस्सा लागू करती है:

INSTANCE: my-stream input-stream    ! readable
INSTANCE: my-stream output-stream   ! writable

एक स्ट्रीम इनमें से एक हो सकती है, दूसरी हो सकती है, या दोनों। फिर input-stream (या output-stream) पर बने जेनेरिक मेथड उस हर क्लास पर लागू हो जाते हैं जो उस मिक्सिन से जुड़ी है। इसी तरह आसपास उपलब्ध read1, stream-contents, with-input-stream जैसे शब्द आपकी क्लास तक पहुँचते हैं।

मिक्सिन ओपन होते हैं: किसी मिक्सिन के घोषित हो जाने के बाद भी आप उसमें नया सदस्य जोड़ सकते हैं, चाहे वह किसी और वोकैबुलरी में हो। इसके उलट TUPLE: < parent है, जहाँ यह संबंध तभी तय हो जाता है जब चाइल्ड क्लास घोषित की जाती है।

प्रोटोकॉल के जेनेरिक

प्रोटोकॉल के जेनेरिक io में रहते हैं:

stream-read1         ( stream -- elt/f )
stream-read          ( n stream -- seq/f )
stream-read-unsafe   ( n buf stream -- count )
stream-write1        ( elt stream -- )
stream-write         ( seq stream -- )
stream-flush         ( stream -- )
stream-element-type  ( stream -- type )

stream-read1 अगला बाइट लौटाता है (या स्ट्रीम के अंत में f), और stream-write1 एक बाइट लिखता है। stream-read-unsafe निचले स्तर का बैच रीड है, जो ज़्यादातर इनपुट स्ट्रीम देती हैं; stream-read इसी के ऊपर बना है और आवंटन का काम संभालता है। stream-element-type बताता है कि स्ट्रीम बाइट (+byte+) में काम करती है या अक्षर (+character+) में; जब आप किसी दूसरी स्ट्रीम को लपेटते हैं, तो सबसे आसान कार्यान्वयन बस नीचे वाली स्ट्रीम को ही काम सौंप देता है।

क्लीनअप destructors से आता है

स्ट्रीम disposable होती हैं: एक कस्टम स्ट्रीम disposable को एक्सटेंड करती है और dispose* लागू करती है। यही फ्रेमवर्क boatswains-bilge से आता है, जिसे यहाँ एक स्ट्रीम क्लास पर लगाया गया है:

TUPLE: my-stream < disposable underlying ;

: <my-stream> ( underlying -- s )
    my-stream new-disposable swap >>underlying ;

M: my-stream dispose* underlying>> dispose ;

यह सब हो जाने के बाद, channel-chatter से आने वाले सारे with-… कॉम्बिनेटर आपकी स्ट्रीम पर अपने आप काम करने लगते हैं।