X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=c-bindings-gen%2Fsrc%2Ftypes.rs;h=13c3b0ed0c2b7b3b00b4af8e58728a117614d6cb;hb=787d5d9810dfc71006f3ed0c8a21290be5ea6c54;hp=bd0c9c5ceecc8cfcb4aaa8ce175cda800d73ddab;hpb=56001280fb0fa4591492dc3766b8509dd51826e6;p=ldk-c-bindings

diff --git a/c-bindings-gen/src/types.rs b/c-bindings-gen/src/types.rs
index bd0c9c5..13c3b0e 100644
--- a/c-bindings-gen/src/types.rs
+++ b/c-bindings-gen/src/types.rs
@@ -723,6 +723,14 @@ impl FullLibraryAST {
 fn initial_clonable_types() -> HashSet<String> {
 	let mut res = HashSet::new();
 	res.insert("crate::c_types::u5".to_owned());
+	res.insert("crate::c_types::ThirtyTwoBytes".to_owned());
+	res.insert("crate::c_types::PublicKey".to_owned());
+	res.insert("crate::c_types::Transaction".to_owned());
+	res.insert("crate::c_types::TxOut".to_owned());
+	res.insert("crate::c_types::Signature".to_owned());
+	res.insert("crate::c_types::RecoverableSignature".to_owned());
+	res.insert("crate::c_types::Secp256k1Error".to_owned());
+	res.insert("crate::c_types::IOError".to_owned());
 	res
 }
 
@@ -850,9 +858,6 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> {
 		if self.is_primitive(ty) { return true; }
 		match ty {
 			"()" => true,
-			"crate::c_types::Signature" => true,
-			"crate::c_types::RecoverableSignature" => true,
-			"crate::c_types::TxOut" => true,
 			_ => false,
 		}
 	}
@@ -950,6 +955,7 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> {
 
 			"str" if is_ref => Some(""),
 			"alloc::string::String"|"String" => Some(""),
+			"std::io::Error" if !is_ref => Some(""),
 			// Note that we'll panic for String if is_ref, as we only have non-owned memory, we
 			// cannot create a &String.
 
@@ -1016,6 +1022,7 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> {
 
 			"str" if is_ref => Some(".into_str()"),
 			"alloc::string::String"|"String" => Some(".into_string()"),
+			"std::io::Error" if !is_ref => Some(".to_rust()"),
 
 			"std::time::Duration"|"core::time::Duration" => Some(")"),
 			"std::time::SystemTime" => Some("))"),
@@ -1256,7 +1263,7 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> {
 	}
 	/// Returns true if the path is a "transparent" container, ie an Option or a container which does
 	/// not require a generated continer class.
-	fn is_path_transparent_container(&self, full_path: &syn::Path, generics: Option<&GenericTypes>, is_ref: bool) -> bool {
+	pub fn is_path_transparent_container(&self, full_path: &syn::Path, generics: Option<&GenericTypes>, is_ref: bool) -> bool {
 		let inner_iter = match &full_path.segments.last().unwrap().arguments {
 			syn::PathArguments::None => return false,
 			syn::PathArguments::AngleBracketed(args) => args.args.iter().map(|arg| {
@@ -1283,16 +1290,15 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> {
 							(").into(), Err(mut e) => crate::c_types::CResultTempl::err(".to_string(), "e".to_string())],
 						").into() }", ContainerPrefixLocation::PerConv))
 			},
-			"Vec" if !is_ref => {
-				Some(("Vec::new(); for mut item in ", vec![(format!(".drain(..) {{ local_{}.push(", var_name), "item".to_string())], "); }", ContainerPrefixLocation::PerConv))
-			},
 			"Vec" => {
-				// We should only get here if the single contained has an inner
-				assert!(self.c_type_has_inner(single_contained.unwrap()));
-				Some(("Vec::new(); for mut item in ", vec![(format!(".drain(..) {{ local_{}.push(", var_name), "*item".to_string())], "); }", ContainerPrefixLocation::PerConv))
+				if is_ref {
+					// We should only get here if the single contained has an inner
+					assert!(self.c_type_has_inner(single_contained.unwrap()));
+				}
+				Some(("Vec::new(); for mut item in ", vec![(format!(".drain(..) {{ local_{}.push(", var_name), "item".to_string())], "); }", ContainerPrefixLocation::PerConv))
 			},
 			"Slice" => {
-				Some(("Vec::new(); for item in ", vec![(format!(".iter() {{ local_{}.push(", var_name), "*item".to_string())], "); }", ContainerPrefixLocation::PerConv))
+				Some(("Vec::new(); for item in ", vec![(format!(".iter() {{ local_{}.push(", var_name), "item".to_string())], "); }", ContainerPrefixLocation::PerConv))
 			},
 			"Option" => {
 				let contained_struct = if let Some(syn::Type::Path(p)) = single_contained {