X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=lightning%2Fsrc%2Flib.rs;h=e1ae9433e23495c70bb0db99953debf0b4104e8d;hb=0dfcacd22c23f69b6526c9c6507d21427a2b7ccb;hp=a9f46b43a4026f650069cb97f9baf1dd62a0d968;hpb=c05347f48a4ff2789ae261ee8c8f3f4277489420;p=rust-lightning

diff --git a/lightning/src/lib.rs b/lightning/src/lib.rs
index a9f46b43..e1ae9433 100644
--- a/lightning/src/lib.rs
+++ b/lightning/src/lib.rs
@@ -28,21 +28,125 @@
 #![allow(bare_trait_objects)]
 #![allow(ellipsis_inclusive_range_patterns)]
 
+#![cfg_attr(all(not(feature = "std"), not(test)), no_std)]
+
 #![cfg_attr(all(any(test, feature = "_test_utils"), feature = "unstable"), feature(test))]
 #[cfg(all(any(test, feature = "_test_utils"), feature = "unstable"))] extern crate test;
 
+#[cfg(not(any(feature = "std", feature = "no_std")))]
+compile_error!("at least one of the `std` or `no_std` features must be enabled");
+
+#[macro_use]
 extern crate alloc;
 extern crate bitcoin;
+#[cfg(any(test, feature = "std"))]
 extern crate core;
+
 #[cfg(any(test, feature = "_test_utils"))] extern crate hex;
 #[cfg(any(test, feature = "fuzztarget", feature = "_test_utils"))] extern crate regex;
 
+#[cfg(not(feature = "std"))] extern crate core2;
+
 #[macro_use]
 pub mod util;
 pub mod chain;
 pub mod ln;
 pub mod routing;
 
+#[cfg(feature = "std")]
+use std::io;
+#[cfg(not(feature = "std"))]
+use core2::io;
+
+#[cfg(not(feature = "std"))]
+mod io_extras {
+	use core2::io::{self, Read, Write};
+
+	/// A writer which will move data into the void.
+	pub struct Sink {
+		_priv: (),
+	}
+
+	/// Creates an instance of a writer which will successfully consume all data.
+	pub const fn sink() -> Sink {
+		Sink { _priv: () }
+	}
+
+	impl core2::io::Write for Sink {
+		#[inline]
+		fn write(&mut self, buf: &[u8]) -> core2::io::Result<usize> {
+			Ok(buf.len())
+		}
+
+		#[inline]
+		fn flush(&mut self) -> core2::io::Result<()> {
+			Ok(())
+		}
+	}
+
+	pub fn copy<R: ?Sized, W: ?Sized>(reader: &mut R, writer: &mut W) -> Result<u64, io::Error>
+		where
+		R: Read,
+		W: Write,
+	{
+		let mut count = 0;
+		let mut buf = [0u8; 64];
+
+		loop {
+			match reader.read(&mut buf) {
+				Ok(0) => break,
+				Ok(n) => { writer.write_all(&buf[0..n])?; count += n as u64; },
+				Err(ref e) if e.kind() == io::ErrorKind::Interrupted => {},
+				Err(e) => return Err(e.into()),
+			};
+		}
+		Ok(count)
+	}
+
+	pub fn read_to_end<D: io::Read>(mut d: D) -> Result<alloc::vec::Vec<u8>, io::Error> {
+		let mut result = vec![];
+		let mut buf = [0u8; 64];
+		loop {
+			match d.read(&mut buf) {
+				Ok(0) => break,
+				Ok(n) => result.extend_from_slice(&buf[0..n]),
+				Err(ref e) if e.kind() == io::ErrorKind::Interrupted => {},
+				Err(e) => return Err(e.into()),
+			};
+		}
+		Ok(result)
+	}
+}
+
+#[cfg(feature = "std")]
+mod io_extras {
+	pub fn read_to_end<D: ::std::io::Read>(mut d: D) -> Result<Vec<u8>, ::std::io::Error> {
+		let mut buf = Vec::new();
+		d.read_to_end(&mut buf)?;
+		Ok(buf)
+	}
+
+	pub use std::io::{copy, sink};
+}
+
 mod prelude {
-	pub use alloc::{vec, vec::Vec, string::String};
-}
\ No newline at end of file
+	#[cfg(feature = "hashbrown")]
+	extern crate hashbrown;
+
+	pub use alloc::{vec, vec::Vec, string::String, collections::VecDeque, boxed::Box};
+	#[cfg(not(feature = "hashbrown"))]
+	pub use std::collections::{HashMap, HashSet, hash_map};
+	#[cfg(feature = "hashbrown")]
+	pub use self::hashbrown::{HashMap, HashSet, hash_map};
+
+	pub use alloc::borrow::ToOwned;
+	pub use alloc::string::ToString;
+}
+
+#[cfg(feature = "std")]
+mod sync {
+	pub use ::std::sync::{Arc, Mutex, Condvar, MutexGuard, RwLock, RwLockReadGuard};
+}
+
+#[cfg(not(feature = "std"))]
+mod sync;