src/test/run-pass/pipe-presentation-examples.rs

   1 // xfail-fast
   2 // xfail-test
   3
   4 // XFAIL'd because this is going to be revamped, and it's not compatible as
   5 // written with the new mutability rules.
   6
   7 // Copyright 2012 The Rust Project Developers. See the COPYRIGHT
   8 // file at the top-level directory of this distribution and at
   9 // http://rust-lang.org/COPYRIGHT.
  10 //
  11 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
  12 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
  13 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
  14 // option. This file may not be copied, modified, or distributed
  15 // except according to those terms.
  16
  17 // Examples from Eric's internship final presentation.
  18 //
  19 // Code is easier to write in emacs, and it's good to be sure all the
  20 // code samples compile (or not) as they should.
  21
  22 use double_buffer::client::*;
  23 use double_buffer::give_buffer;
  24 use std::comm::Selectable;
  25
  26 macro_rules! select_if (
  27     {
  28         $index:expr,
  29         $count:expr,
  30         $port:path => [
  31             $($message:path$(($($x: ident),+))dont_type_this*
  32               -> $next:ident $e:expr),+
  33         ],
  34         $( $ports:path => [
  35             $($messages:path$(($($xs: ident),+))dont_type_this*
  36               -> $nexts:ident $es:expr),+
  37         ], )*
  38     } => {
  39         if $index == $count {
  40             match std::pipes::try_recv($port) {
  41               $(Some($message($($($x,)+)* next)) => {
  42                 let $next = next;
  43                 $e
  44               })+
  45               _ => fail!()
  46             }
  47         } else {
  48             select_if!(
  49                 $index,
  50                 $count + 1,
  51                 $( $ports => [
  52                     $($messages$(($($xs),+))dont_type_this*
  53                       -> $nexts $es),+
  54                 ], )*
  55             )
  56         }
  57     };
  58
  59     {
  60         $index:expr,
  61         $count:expr,
  62     } => {
  63         fail!()
  64     }
  65 )
  66
  67 macro_rules! select (
  68     {
  69         $( $port:path => {
  70             $($message:path$(($($x: ident),+))dont_type_this*
  71               -> $next:ident $e:expr),+
  72         } )+
  73     } => ({
  74         let index = std::comm::selecti([$(($port).header()),+]);
  75         select_if!(index, 0, $( $port => [
  76             $($message$(($($x),+))dont_type_this* -> $next $e),+
  77         ], )+)
  78     })
  79 )
  80
  81 // Types and protocols
  82 pub struct Buffer {
  83     foo: (),
  84
  85 }
  86
  87 impl Drop for Buffer {
  88     fn drop(&self) {}
  89 }
  90
  91 proto! double_buffer (
  92     acquire:send {
  93         request -> wait_buffer
  94     }
  95
  96     wait_buffer:recv {
  97         give_buffer(::Buffer) -> release
  98     }
  99
 100     release:send {
 101         release(::Buffer) -> acquire
 102     }
 103 )
 104
 105 // Code examples
 106 fn render(_buffer: &Buffer) {
 107     // A dummy function.
 108 }
 109
 110 fn draw_frame(+channel: double_buffer::client::acquire) {
 111     let channel = request(channel);
 112     select! (
 113         channel => {
 114             give_buffer(buffer) -> channel {
 115                 render(&buffer);
 116                 release(channel, buffer)
 117             }
 118         }
 119     );
 120 }
 121
 122 fn draw_two_frames(+channel: double_buffer::client::acquire) {
 123     let channel = request(channel);
 124     let channel = select! (
 125         channel => {
 126             give_buffer(buffer) -> channel {
 127                 render(&buffer);
 128                 release(channel, buffer)
 129             }
 130         }
 131     );
 132     let channel = request(channel);
 133     select! (
 134         channel => {
 135             give_buffer(buffer) -> channel {
 136                 render(&buffer);
 137                 release(channel, buffer)
 138             }
 139         }
 140     );
 141 }
 142
 143 #[cfg(bad1)]
 144 fn draw_two_frames_bad1(+channel: double_buffer::client::acquire) {
 145     let channel = request(channel);
 146     select! (
 147         channel => {
 148             give_buffer(buffer) -> channel {
 149                 render(&buffer);
 150             }
 151         }
 152     );
 153     let channel = request(channel);
 154     select! (
 155         channel => {
 156             give_buffer(buffer) -> channel {
 157                 render(&buffer);
 158                 release(channel, buffer)
 159             }
 160         }
 161     );
 162 }
 163
 164 #[cfg(bad2)]
 165 fn draw_two_frames_bad2(+channel: double_buffer::client::acquire) {
 166     let channel = request(channel);
 167     select! (
 168         channel => {
 169             give_buffer(buffer) -> channel {
 170                 render(&buffer);
 171                 release(channel, buffer);
 172                 render(&buffer);
 173                 release(channel, buffer);
 174             }
 175         }
 176     );
 177 }
 178
 179 pub fn main() { }