Declare Metadata

Author: Seulgi Kim

core/src/state/metadata.rs

@@ -0,0 +1,118 @@
+// Copyright 2018 Kodebox, Inc.
+// This file is part of CodeChain.
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+//
+// This program 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 Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+use ctypes::H256;
+use rlp::{Decodable, DecoderError, Encodable, RlpStream, UntrustedRlp};
+
+use super::CacheableItem;
+
+#[derive(Clone, Debug)]
+pub struct Metadata {
+    number_of_shards: u32,
+}
+
+impl Metadata {
+    pub fn new(number_of_shards: u32) -> Self {
+        Self {
+            number_of_shards,
+        }
+    }
+
+    pub fn number_of_shards(&self) -> &u32 {
+        &self.number_of_shards
+    }
+}
+
+impl CacheableItem for Metadata {
+    type Address = MetadataAddress;
+
+    fn is_null(&self) -> bool {
+        self.number_of_shards == 0
+    }
+}
+
+const PREFIX: u8 = 'M' as u8;
+
+impl Encodable for Metadata {
+    fn rlp_append(&self, s: &mut RlpStream) {
+        s.begin_list(2).append(&PREFIX).append(&self.number_of_shards);
+    }
+}
+
+impl Decodable for Metadata {
+    fn decode(rlp: &UntrustedRlp) -> Result<Self, DecoderError> {
+        if rlp.item_count()? != 2 {
+            return Err(DecoderError::RlpInvalidLength)
+        }
+        let prefix = rlp.val_at::<u8>(0)?;
+        if PREFIX != prefix {
+            cdebug!(STATE, "{} is not an expected prefix for asset", prefix);
+            return Err(DecoderError::Custom("Unexpected prefix"))
+        }
+        Ok(Self {
+            number_of_shards: rlp.val_at(1)?,
+        })
+    }
+}
+
+#[derive(Clone, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct MetadataAddress(H256);
+
+impl_address!(MetadataAddress, PREFIX);
+
+impl MetadataAddress {
+    pub fn new() -> Self {
+        Self::from_transaction_hash(H256::from_slice(b"metadata address"), 0)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn parse_fail_return_none() {
+        let hash = {
+            let mut hash;
+            loop {
+                hash = H256::random();
+                if hash[0] == PREFIX {
+                    continue
+                }
+                for i in 1..8 {
+                    if hash[i] == 0 {
+                        continue
+                    }
+                }
+                break
+            }
+            hash
+        };
+        let address = MetadataAddress::from_hash(hash);
+        assert!(address.is_none());
+    }
+
+    #[test]
+    fn parse_return_some() {
+        let hash = {
+            let mut hash = H256::random();
+            hash[0..8].clone_from_slice(&[PREFIX, 0, 0, 0, 0, 0, 0, 0]);
+            hash
+        };
+        let address = MetadataAddress::from_hash(hash.clone());
+        assert_eq!(Some(MetadataAddress(hash)), address);
+    }
+}

core/src/state/mod.rs

@@ -39,6 +39,7 @@ mod asset_scheme;
 mod backend;
 mod cache;
 mod info;
+mod metadata;
 mod shard;
 mod shard_level;
 mod shard_metadata;
@@ -53,6 +54,7 @@ pub use self::asset_scheme::{AssetScheme, AssetSchemeAddress};
 pub use self::backend::{Backend, Basic as BasicBackend, ShardBackend, TopBackend};
 pub use self::cache::CacheableItem;
 pub use self::info::{ShardStateInfo, TopStateInfo};
+pub use self::metadata::{Metadata, MetadataAddress};
 pub use self::shard::{Shard, ShardAddress};
 pub use self::shard_metadata::{ShardMetadata, ShardMetadataAddress};
 pub use self::shard_state::{ShardState, TransactionOutcome};