cluExtIO 0.1.7

Syntactic sugar extends I/O capabilities.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146

# cluExtIO

[![Build Status](https://travis-ci.org/clucompany/cluExtIO.svg?branch=master)](https://travis-ci.org/clucompany/cluExtIO)
[![Apache licensed](https://img.shields.io/badge/license-Apache%202.0-blue.svg)](./LICENSE)
[![crates.io](http://meritbadge.herokuapp.com/cluExtIO)](https://crates.io/crates/cluExtIO)
[![Documentation](https://docs.rs/cluExtIO/badge.svg)](https://docs.rs/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. 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