sorting filters & ranges

ethcore/src/client/client.rs.in

@@ -57,7 +57,7 @@ use verification::{PreverifiedBlock, Verifier};
 use block::*;
 use transaction::{LocalizedTransaction, SignedTransaction, Action};
 use blockchain::extras::TransactionAddress;
-use filter::Filter;
+use types::filter::Filter;
 use log_entry::LocalizedLogEntry;
 use block_queue::{BlockQueue, BlockQueueInfo};
 use blockchain::{BlockChain, BlockProvider, TreeRoute, ImportRoute};

ethcore/src/client/mod.rs

@@ -27,7 +27,7 @@ pub use self::config::{ClientConfig, DatabaseCompactionProfile, BlockQueueConfig
 pub use self::error::Error;
 pub use types::ids::*;
 pub use self::test_client::{TestBlockChainClient, EachBlockWith};
-pub use self::trace::Filter as TraceFilter;
+pub use types::trace_filter::Filter as TraceFilter;
 pub use executive::{Executed, Executive, TransactOptions};
 pub use env_info::{LastHashes, EnvInfo};
 

ethcore/src/client/trace.rs

@@ -8,6 +8,7 @@ use trace::DatabaseExtras as TraceDatabaseExtras;
 use blockchain::{BlockChain, BlockProvider};
 use blockchain::extras::TransactionAddress;
 use super::BlockID;
+pub use types::trace_filter::Filter;
 
 impl TraceDatabaseExtras for BlockChain {
 	fn block_hash(&self, block_number: BlockNumber) -> Option<H256> {
@@ -26,13 +27,3 @@ impl TraceDatabaseExtras for BlockChain {
 			.map(|tx| tx.hash())
 	}
 }
-
-/// Easy to use trace filter.
-pub struct Filter {
-	/// Range of filtering.
-	pub range: Range<BlockID>,
-	/// From address.
-	pub from_address: Vec<Address>,
-	/// To address.
-	pub to_address: Vec<Address>,
-}

ethcore/src/lib.rs

@@ -104,7 +104,6 @@ pub mod block_queue;
 pub mod client;
 pub mod error;
 pub mod ethereum;
-pub mod filter;
 pub mod header;
 pub mod service;
 pub mod trace;

ethcore/src/types/filter.rs

@@ -20,6 +20,9 @@ use util::hash::*;
 use util::sha3::*;
 use client::BlockID;
 use log_entry::LogEntry;
+use ipc::binary::BinaryConvertError;
+use std::mem;
+use std::collections::VecDeque;
 
 /// Blockchain Filter.
 pub struct Filter {
@@ -29,22 +32,27 @@ pub struct Filter {
 	/// Till this block.
 	pub to_block: BlockID,
 
-	/// Search addresses. 
-	/// 
+	/// Search addresses.
+	///
 	/// If None, match all.
 	/// If specified, log must be produced by one of these addresses.
 	pub address: Option<Vec<Address>>,
 
 	/// Search topics.
-	/// 
+	///
 	/// If None, match all.
 	/// If specified, log must contain one of these topics.
-	pub topics: [Option<Vec<H256>>; 4],
+	pub topics: Vec<Option<Vec<H256>>>,
 }
 
 impl Clone for Filter {
 	fn clone(&self) -> Self {
-		let mut topics = [None, None, None, None];
+		let mut topics = [
+			None,
+			None,
+			None,
+			None,
+		];
 		for i in 0..4 {
 			topics[i] = self.topics[i].clone();
 		}
@@ -53,13 +61,13 @@ impl Clone for Filter {
 			from_block: self.from_block.clone(),
 			to_block: self.to_block.clone(),
 			address: self.address.clone(),
-			topics: topics
+			topics: topics[..].to_vec()
 		}
 	}
 }
 
 impl Filter {
-	/// Returns combinations of each address and topic.	
+	/// Returns combinations of each address and topic.
 	pub fn bloom_possibilities(&self) -> Vec<H2048> {
 		let blooms = match self.address {
 			Some(ref addresses) if !addresses.is_empty() =>
@@ -71,7 +79,7 @@ impl Filter {
 			_ => vec![H2048::new()]
 		};
 
-		self.topics.iter().fold(blooms, | bs, topic | match *topic {
+		self.topics.iter().fold(blooms, |bs, topic| match *topic {
 			None => bs,
 			Some(ref topics) => bs.into_iter().flat_map(|bloom| {
 				topics.into_iter().map(|topic| {

ethcore/src/types/mod.rs.in

@@ -27,3 +27,5 @@ pub mod account_diff;
 pub mod state_diff;
 pub mod block_queue_info;
 pub mod transaction_import_result;
+pub mod filter;
+pub mod trace_filter;

ethcore/src/types/trace_filter.rs

@@ -0,0 +1,33 @@
+// Copyright 2015, 2016 Ethcore (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
+
+use std::mem;
+use ipc::binary::{BinaryConvertError, BinaryConvertable};
+use std::collections::VecDeque;
+use std::ops::Range;
+use util::{Address, H256};
+use types::ids::BlockID;
+
+/// Easy to use trace filter.
+#[derive(Binary)]
+pub struct Filter {
+	/// Range of filtering.
+	pub range: Range<BlockID>,
+	/// From address.
+	pub from_address: Vec<Address>,
+	/// To address.
+	pub to_address: Vec<Address>,
+}

ethcore/src/types/transaction_import_result.rs

@@ -18,7 +18,7 @@ use std::mem;
 use ipc::binary::BinaryConvertError;
 use std::collections::VecDeque;
 
-#[derive(Debug, Clone, PartialEq)]
+#[derive(Debug, Clone, PartialEq, Binary)]
 /// Represents the result of importing transaction.
 pub enum TransactionImportResult {
 	/// Transaction was imported to current queue.

ipc/rpc/src/binary.rs

@@ -319,6 +319,31 @@ impl BinaryConvertable for String {
 	}
 }
 
+impl<T> BinaryConvertable for Range<T> where T: BinaryConvertable {
+	fn size(&self) -> usize {
+		mem::size_of::<T>() * 2
+	}
+
+	fn from_empty_bytes() -> Result<Self, BinaryConvertError> {
+		Err(BinaryConvertError)
+	}
+
+	fn to_bytes(&self, buffer: &mut[u8], length_stack: &mut VecDeque<usize>) -> Result<(), BinaryConvertError> {
+		try!(self.start.to_bytes(&mut buffer[..mem::size_of::<T>()], length_stack));
+		try!(self.end.to_bytes(&mut buffer[mem::size_of::<T>() + 1..], length_stack));
+		Ok(())
+	}
+
+	fn from_bytes(buffer: &[u8], length_stack: &mut VecDeque<usize>) -> Result<Self, BinaryConvertError> {
+		Ok(try!(T::from_bytes(&buffer[..mem::size_of::<T>()], length_stack))..try!(T::from_bytes(&buffer[mem::size_of::<T>()+1..], length_stack)))
+	}
+
+	fn len_params() -> usize {
+		assert_eq!(0, T::len_params());
+		0
+	}
+}
+
 impl<T> BinaryConvertable for ::std::cell::RefCell<T> where T: BinaryConvertable {
 	fn size(&self) -> usize {
 		self.borrow().size()
@@ -543,8 +568,6 @@ binary_fixed_size!(U512);
 binary_fixed_size!(H256);
 binary_fixed_size!(H2048);
 binary_fixed_size!(Address);
-binary_fixed_size!(Range<usize>);
-binary_fixed_size!(Range<u64>);
 
 #[test]
 fn vec_serialize() {