Add no_std feature

capnp/Cargo.toml

@@ -20,13 +20,16 @@ path = "src/lib.rs"
 
 [dependencies]
 quickcheck = { version = "0.2", optional = true }
+core_io = { version = "0.1.20190701", features = [ "alloc", "collections" ], optional = true }
 
 [dev-dependencies]
 quickcheck = "0.2"
 
 [features]
+no_std = ["core_io"]
 rpc = ["futures"]
 rpc_try = []
+default = []
 
 [dependencies.futures]
 version = "0.1"

capnp/src/any_pointer.rs

@@ -21,6 +21,9 @@
 
 //! Dynamically typed value.
 
+#[cfg(feature = "no_std")]
+use crate::io::prelude::*;
+
 use crate::capability::FromClientHook;
 use crate::private::capability::{ClientHook, PipelineHook, PipelineOp};
 use crate::private::layout::{PointerReader, PointerBuilder};

capnp/src/any_pointer_list.rs

@@ -23,6 +23,7 @@
 //! Note: this cannot be used for a list of structs, since such lists are not encoded
 //! as pointer lists.
 
+use core;
 use crate::traits::{FromPointerReader, FromPointerBuilder, ListIter, IndexMove};
 use crate::private::layout::{ListReader, ListBuilder, PointerReader, PointerBuilder, Pointer};
 use crate::Result;
@@ -124,7 +125,7 @@ impl <'a> crate::traits::SetPointerBuilder<Builder<'a>> for Reader<'a> {
     }
 }
 
-impl <'a> ::std::iter::IntoIterator for Reader<'a> {
+impl <'a> core::iter::IntoIterator for Reader<'a> {
     type Item = Result<crate::any_pointer::Reader<'a>>;
     type IntoIter = ListIter<Reader<'a>, Self::Item>;
 

capnp/src/capability.rs

@@ -23,6 +23,10 @@
 //!
 //! Roughly corresponds to capability.h in the C++ implementation.
 
+#[cfg(feature = "no_std")]
+use crate::io::prelude::*;
+use core::marker::PhantomData;
+
 use crate::{any_pointer, Error, MessageSize};
 use crate::traits::{Pipelined, Owned};
 use crate::private::capability::{ClientHook, ParamsHook, RequestHook, ResponseHook, ResultsHook};
@@ -32,8 +36,6 @@ use futures::Future;
 #[cfg(feature = "rpc_try")]
 use std::ops::Try;
 
-use std::marker::PhantomData;
-
 /// A computation that might eventually resolve to a value of type `T` or to an error
 ///  of type `E`. Dropping the promise cancels the computation.
 #[must_use = "futures do nothing unless polled"]

capnp/src/capability_list.rs

@@ -20,7 +20,9 @@
 
 //! List of capabilities.
 
-use std::marker::PhantomData;
+#[cfg(feature = "no_std")]
+use crate::io::prelude::*;
+use core::{self, marker::PhantomData};
 
 use crate::capability::{FromClientHook};
 use crate::private::capability::ClientHook;
@@ -152,7 +154,7 @@ impl <'a, T> crate::traits::SetPointerBuilder<Builder<'a, T>> for Reader<'a, T>
     }
 }
 
-impl <'a, T> ::std::iter::IntoIterator for Reader<'a, T>
+impl <'a, T> core::iter::IntoIterator for Reader<'a, T>
     where T: FromClientHook
 {
     type Item = Result<T>;

capnp/src/constant.rs

@@ -23,8 +23,7 @@
 //! `constant::Reader` does not do bounds-checking, so it is unsafe to
 //! manually construct one of these.
 
-use std::marker::PhantomData;
-
+use core::marker::PhantomData;
 use crate::any_pointer;
 use crate::private::layout::PointerReader;
 use crate::traits::Owned;

capnp/src/data.rs

@@ -21,6 +21,7 @@
 
 //! Sequence of bytes.
 
+use core;
 use crate::private::layout::{PointerBuilder, PointerReader};
 use crate::Result;
 
@@ -35,7 +36,7 @@ impl<'a> crate::traits::Owned<'a> for Owned {
 pub type Reader<'a> = &'a [u8];
 
 pub fn new_reader<'a>(p : *const u8, len : u32) -> Reader<'a> {
-    unsafe { ::std::slice::from_raw_parts(p, len as usize) }
+    unsafe { core::slice::from_raw_parts(p, len as usize) }
 }
 
 impl <'a> crate::traits::FromPointerReader<'a> for Reader<'a> {
@@ -47,7 +48,7 @@ impl <'a> crate::traits::FromPointerReader<'a> for Reader<'a> {
 pub type Builder<'a> = &'a mut [u8];
 
 pub fn new_builder<'a>(p : *mut u8, len : u32) -> Builder<'a> {
-    unsafe { ::std::slice::from_raw_parts_mut(p, len as usize) }
+    unsafe { core::slice::from_raw_parts_mut(p, len as usize) }
 }
 
 impl <'a> crate::traits::FromPointerBuilder<'a> for Builder<'a> {

capnp/src/data_list.rs

@@ -21,6 +21,7 @@
 
 //! List of sequences of bytes.
 
+use core;
 use crate::traits::{FromPointerReader, FromPointerBuilder, IndexMove, ListIter};
 use crate::private::layout::*;
 use crate::Result;
@@ -133,7 +134,7 @@ impl <'a> crate::traits::SetPointerBuilder<Builder<'a>> for Reader<'a> {
     }
 }
 
-impl <'a> ::std::iter::IntoIterator for Reader<'a> {
+impl <'a> core::iter::IntoIterator for Reader<'a> {
     type Item = Result<crate::data::Reader<'a>>;
     type IntoIter = ListIter<Reader<'a>, Self::Item>;
 

capnp/src/enum_list.rs

@@ -21,14 +21,14 @@
 
 //! List of enums.
 
+use core::{self, marker::PhantomData};
+
 use crate::traits::{FromPointerReader, FromPointerBuilder,
                     ToU16, FromU16, ListIter, IndexMove};
 use crate::private::layout::{ListReader, ListBuilder, PointerReader, PointerBuilder,
                              TwoBytes, PrimitiveElement};
 use crate::{NotInSchema, Result};
 
-use std::marker::PhantomData;
-
 #[derive(Clone, Copy)]
 pub struct Owned<T> {
     marker: PhantomData<T>,
@@ -52,7 +52,7 @@ impl <'a, T: FromU16> Reader<'a, T> {
 
     pub fn len(&self) -> u32 { self.reader.len() }
 
-    pub fn iter(self) -> ListIter<Reader<'a, T>, ::std::result::Result<T, NotInSchema>>{
+    pub fn iter(self) -> ListIter<Reader<'a, T>, core::result::Result<T, NotInSchema>>{
         let l = self.len();
         ListIter::new(self, l)
     }
@@ -65,14 +65,14 @@ impl <'a, T : FromU16> FromPointerReader<'a> for Reader<'a, T> {
     }
 }
 
-impl <'a, T: FromU16>  IndexMove<u32, ::std::result::Result<T, NotInSchema>> for Reader<'a, T>{
-    fn index_move(&self, index: u32) -> ::std::result::Result<T, NotInSchema> {
+impl <'a, T: FromU16>  IndexMove<u32, core::result::Result<T, NotInSchema>> for Reader<'a, T>{
+    fn index_move(&self, index: u32) -> core::result::Result<T, NotInSchema> {
         self.get(index)
     }
 }
 
 impl <'a, T : FromU16> Reader<'a, T> {
-    pub fn get(&self, index: u32) -> ::std::result::Result<T, NotInSchema> {
+    pub fn get(&self, index: u32) -> core::result::Result<T, NotInSchema> {
         assert!(index < self.len());
         let result: u16 = PrimitiveElement::get(&self.reader, index);
         FromU16::from_u16(result)
@@ -119,7 +119,7 @@ impl <'a, T : FromU16> FromPointerBuilder<'a> for Builder<'a, T> {
 }
 
 impl <'a, T : ToU16 + FromU16>  Builder<'a, T> {
-    pub fn get(&self, index: u32) -> ::std::result::Result<T, NotInSchema> {
+    pub fn get(&self, index: u32) -> core::result::Result<T, NotInSchema> {
         assert!(index < self.len());
         let result: u16 = PrimitiveElement::get_from_builder(&self.builder, index);
         FromU16::from_u16(result)
@@ -138,8 +138,8 @@ impl <'a, T> crate::traits::SetPointerBuilder<Builder<'a, T>> for Reader<'a, T>
     }
 }
 
-impl <'a, T: FromU16> ::std::iter::IntoIterator for Reader<'a, T> {
-    type Item = ::std::result::Result<T, NotInSchema>;
+impl <'a, T: FromU16> core::iter::IntoIterator for Reader<'a, T> {
+    type Item = core::result::Result<T, NotInSchema>;
     type IntoIter = ListIter<Reader<'a, T>, Self::Item>;
 
     fn into_iter(self) -> Self::IntoIter {