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

diff --git a/lightning/src/lib.rs b/lightning/src/lib.rs
index e466205c..e1ae9433 100644
--- a/lightning/src/lib.rs
+++ b/lightning/src/lib.rs
@@ -19,7 +19,8 @@
 //! instead of having a rather-separate lightning appendage to a wallet.
 
 #![cfg_attr(not(any(feature = "fuzztarget", feature = "_test_utils")), deny(missing_docs))]
-#![forbid(unsafe_code)]
+#![cfg_attr(not(any(test, feature = "fuzztarget", feature = "_test_utils")), forbid(unsafe_code))]
+#![deny(broken_intra_doc_links)]
 
 // In general, rust is absolutely horrid at supporting users doing things like,
 // for example, compiling Rust code for real environments. Disable useless lints
@@ -27,12 +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 {
+	#[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;