نوار تلگرافچی

شما پیشتر در channel-chatter از جریان‌ها استفاده کرده‌اید و در boatswains-bilge آن‌ها را دور انداخته‌اید. این تمرین نخستین جریان سفارشی شماست: کلاسی که پروتکل را پیاده‌سازی می‌کند تا همان کد with-input-stream / read1 / stream-read1 که روی یک <string-reader> کار می‌کرد، روی جریان شما هم کار کند.

میکسین‌ها: نیمه‌ی دیگر سلسله‌مراتب کلاس

شما TUPLE: child < parent … را از dragons-descendants می‌شناسید: سلسله‌مراتبی تک‌والدی که در آن خانه‌ها به پایین می‌رسند. 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 را گسترش می‌دهد و dispose* را پیاده‌سازی می‌کند. این همان چارچوبی است از boatswains-bilge که این بار روی یک کلاس جریان اعمال شده است:

TUPLE: my-stream < disposable underlying ;

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

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

وقتی این کار انجام شد، همه‌ی ترکیب‌کننده‌های with-… از channel-chatter به‌طور خودکار روی جریان شما کار می‌کنند.