3 releases

0.1.7 Dec 17, 2018
0.1.6 Dec 15, 2018
0.1.2 Nov 9, 2018

#1741 in Development tools

39 downloads per month

Apache-2.0

24KB
471 lines

cluExtIO

Build Status Apache licensed Documentation

Syntactic sugar extends I/O capabilities.

Capabilities:

  1. EmptyWrite - Empty "Write" that does nothing.
  2. UnionWrite - Possibility to combine several "Write" into one record.
  3. MutexWrite - Combining Mutex and Write for multi-threaded access.
  4. ExtWrite - The trait extends the capabilities of the standard Write, adds lock methods.
  5. FlushDropWrite - An implementation of "Trait Write", which calls the flush () method on drop.
  6. FlushLockWrite - An implementation of "Trait Write" that calls the flush() method when removing a lock.
  7. NotChanWrite - Unchangeable "Trait Write". ...

Use

  1. UnionWrite

     extern crate cluExtIO;
    
     use std::io::Write;
     use cluExtIO::UnionWriteConst;
     use std::fs::File;
    
     pub fn main() {
    
     		 let file1 = File::create("/tmp/1.out").unwrap();
     		 //file1 - `Write trait`
    
     		 let file2 = File::create("/tmp/2.out").unwrap();
     		 //file2 - `Write trait`
    
     		 let write = file1.union(file2);
     		 //UnionWrite - `FILE1+FILE2`
    
    
     		 my_function(write).unwrap();
     }
    
     fn my_function<W: Write>(mut w: W) -> Result<(), std::io::Error> {
     		 w.write_fmt(format_args!("#@{} {}\n", 1, "Test"))?;
     		 w.write_fmt(format_args!("#@{} {}\n", 2, "MyString"))?;
     		 w.write_fmt(format_args!("#@{} {}\n", 3, "MyString"))?;
    
     		 Ok( () )
     }
    
  2. ExtWrite

     extern crate cluExtIO;
    
     use cluExtIO::ExtWrite;
     use std::io::Write;
    
     pub fn main() {
     		let out = std::io::stdout();
    
     		my_function(&out, 0, "No eND:)").unwrap();
    
     		out.lock_fn(|mut l| {
     				l.write(b"End.\n")
     		}).unwrap();
     }
    
     fn my_function<'a, W: ExtWrite<'a>>(raw_write: &'a W, n: usize, str: &'static str) -> Result<(), std::io::Error> {
     		let mut lock = raw_write.lock();
    
     		lock.write_fmt(format_args!("#@{} {}\n", n, "Test"))?;
     		lock.write_fmt(format_args!("#@{} {}\n", n+1, "MyString"))?;
     		lock.write_fmt(format_args!("#@{} ~{}\n", n+2, str))?;
    
     		Ok( () )
     }
    
  3. Threads

     extern crate cluExtIO;
    
     use std::io::stdout;
     use cluExtIO::UnionWriteConst;
     use cluExtIO::ExtWrite;
     use cluExtIO::MutexWrite;
     use cluExtIO::FlushLockWrite;
     use cluExtIO::NotChanWrite;
     use std::io::Write;
     use std::fs::File;
     use std::sync::Arc;
     use std::sync::Barrier;
     use std::thread;
    
     pub fn main() {
     		 let arc_out = Arc::new({       
     				let out = stdout();
    
     				let file = FlushLockWrite::new(MutexWrite::new(File::create("/tmp/file.out").unwrap()));
     				//Contains the implementation of ExtWrite. Safe for inter-thread space.
     				//+ Additional self-cleaning after destroying Lock
    
     				let file2 = FlushLockWrite::new(MutexWrite::new(File::create("/tmp/file2.out").unwrap()));
     				//Contains the implementation of ExtWrite. Safe for inter-thread space.
     				//+ Additional self-cleaning after destroying Lock
    
     				out.union(file).union(file2)
     		 }); //Combined `ExtWrite` with lock function. OUT_PIPE + FILE_PIPE(2) = UNION_SAFE_PIPE
    
    
     		 let barrier = Arc::new(Barrier::new(5 + 1));
    
     		 for num_thread in 0..5 {
     				let barrier = barrier.clone();
     				let arc_out = arc_out.clone();
     				thread::spawn(move || {
    
     						arc_out.lock_fn(|mut lock| {
     								lock.write_fmt(format_args!("#@{} {}\n", num_thread, "Thread #OK")).unwrap();
     								lock.write_fmt(format_args!("#@{} {}\n", num_thread, "Thread #T")).unwrap();
     						});
    
     						barrier.wait();
     				});
     		 }
    
     		 barrier.wait();
    
     		 arc_out.write_fmt(format_args!("#@{} {}\n", 999, "Thread pull end.")).unwrap();
     		 //Arc<UnionWrite>, auto lock methods. (NotChanWrite)
    
     		 // /tmp/file.out+
     		 // /tmp/file.out+
     }
    

License

Copyright 2018 #UlinProject Денис Котляров

Licensed under the Apache License, Version 2.0

No runtime deps