Crate cluExtIO

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. StdLock

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.

     // /tmp/file.out+
     // /tmp/file.out+
}

License

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

Licensed under the Apache License, Version 2.0

Structs

EmptyWrite

An implementation of Trait Write that does nothing.

FlushDropWrite

An implementation of Trait Write, which calls the flush() method on drop.

FlushLockWrite

An implementation of Trait Write that calls the flush() method when removing a lock.

GuardWrite

MutexWrite

Combining multiple Trait Write into one common.

UnionWrite

Traits

ExtWrite

The trait extends the capabilities of the standard Write.

ImMutWrite

Unchangeable Trait Write.

UnionWriteConst

Implementing the Union Write constructor for Write.

Type Aliases

GuardEmptyWrite