Big rework: replace traits with specializations

Related changes:

- For now: remove impl Dimension from Dataspace
- Remove Clone from Dataspace/PropertyList, replace with .copy()
- Remove FromID and ID traits

Author: aldanor

hdf5-rs/src/container.rs

@@ -1,6 +1,5 @@
 use ffi::h5d::H5Dopen2;
 use ffi::h5g::{H5G_info_t, H5Gget_info, H5Gcreate2, H5Gopen2};
-use ffi::h5i::hid_t;
 use ffi::h5l::{H5Lmove, H5Lcreate_soft, H5Lcreate_hard, H5Ldelete, H5L_SAME_LOC};
 use ffi::h5p::{H5Pcreate, H5Pset_create_intermediate_group, H5P_DEFAULT};
 use globals::H5P_LINK_CREATE;
@@ -9,18 +8,13 @@ use dataset::{Dataset, DatasetBuilder};
 use datatype::ToDatatype;
 use error::Result;
 use group::Group;
-use handle::{ID, FromID};
-use location::Location;
+use location::LocationType;
+use object::{Object, ObjectID};
 use plist::PropertyList;
 use util::to_cstring;
 
 use std::default::Default;
 
-fn group_info(id: hid_t) -> Result<H5G_info_t> {
-    let info: *mut H5G_info_t = &mut H5G_info_t::default();
-    h5call!(H5Gget_info(id, info)).and(Ok(unsafe { *info }))
-}
-
 fn make_lcpl() -> Result<PropertyList> {
     h5lock!({
         let lcpl = PropertyList::from_id(h5try!(H5Pcreate(*H5P_LINK_CREATE)))?;
@@ -29,19 +23,26 @@ fn make_lcpl() -> Result<PropertyList> {
 }
 
 /// A trait for HDF5 objects that can contain other objects (file, group).
-pub trait Container: Location {
+pub trait ContainerType : LocationType {}
+
+impl<T: ContainerType> Object<T> {
+    fn group_info(&self) -> Result<H5G_info_t> {
+        let info: *mut H5G_info_t = &mut H5G_info_t::default();
+        h5call!(H5Gget_info(self.id(), info)).and(Ok(unsafe { *info }))
+    }
+
     /// Returns the number of objects in the container (or 0 if the container is invalid).
-    fn len(&self) -> u64 {
-        group_info(self.id()).map(|info| info.nlinks).unwrap_or(0)
+    pub fn len(&self) -> u64 {
+        self.group_info().map(|info| info.nlinks).unwrap_or(0)
     }
 
     /// Returns true if the container has no linked objects (or if the container is invalid).
-    fn is_empty(&self) -> bool {
+    pub fn is_empty(&self) -> bool {
         self.len() == 0
     }
 
     /// Create a new group in a file or group.
-    fn create_group(&self, name: &str) -> Result<Group> {
+    pub fn create_group(&self, name: &str) -> Result<Group> {
         h5lock!({
             let lcpl = make_lcpl()?;
             let name = to_cstring(name)?;
@@ -52,14 +53,14 @@ pub trait Container: Location {
     }
 
     /// Opens an existing group in a file or group.
-    fn group(&self, name: &str) -> Result<Group> {
+    pub fn group(&self, name: &str) -> Result<Group> {
         let name = to_cstring(name)?;
         Group::from_id(h5try!(H5Gopen2(
             self.id(), name.as_ptr(), H5P_DEFAULT)))
     }
 
     /// Creates a soft link. Note: `src` and `dst` are relative to the current object.
-    fn link_soft(&self, src: &str, dst: &str) -> Result<()> {
+    pub fn link_soft(&self, src: &str, dst: &str) -> Result<()> {
         h5lock!({
             let lcpl = make_lcpl()?;
             let src = to_cstring(src)?;
@@ -71,7 +72,7 @@ pub trait Container: Location {
     }
 
     /// Creates a hard link. Note: `src` and `dst` are relative to the current object.
-    fn link_hard(&self, src: &str, dst: &str) -> Result<()> {
+    pub fn link_hard(&self, src: &str, dst: &str) -> Result<()> {
         let src = to_cstring(src)?;
         let dst = to_cstring(dst)?;
         h5call!(H5Lcreate_hard(
@@ -80,7 +81,7 @@ pub trait Container: Location {
     }
 
     /// Relinks an object. Note: `name` and `path` are relative to the current object.
-    fn relink(&self, name: &str, path: &str) -> Result<()> {
+    pub fn relink(&self, name: &str, path: &str) -> Result<()> {
         let name = to_cstring(name)?;
         let path = to_cstring(path)?;
         h5call!(H5Lmove(
@@ -89,20 +90,20 @@ pub trait Container: Location {
     }
 
     /// Removes a link to an object from this file or group.
-    fn unlink(&self, name: &str) -> Result<()> {
+    pub fn unlink(&self, name: &str) -> Result<()> {
         let name = to_cstring(name)?;
         h5call!(H5Ldelete(
             self.id(), name.as_ptr(), H5P_DEFAULT
         )).and(Ok(()))
     }
 
     /// Instantiates a new dataset builder.
-    fn new_dataset<T: ToDatatype>(&self) -> DatasetBuilder<T> {
-        DatasetBuilder::<T>::new::<Self>(self)
+    pub fn new_dataset<D: ToDatatype>(&self) -> DatasetBuilder<D> {
+        DatasetBuilder::<D>::new(&self)
     }
 
     /// Opens an existing dataset in the file or group.
-    fn dataset(&self, name: &str) -> Result<Dataset> {
+    pub fn dataset(&self, name: &str) -> Result<Dataset> {
         let name = to_cstring(name)?;
         Dataset::from_id(h5try!(H5Dopen2(
             self.id(), name.as_ptr(), H5P_DEFAULT)))
@@ -112,10 +113,8 @@ pub trait Container: Location {
 #[cfg(test)]
 mod tests {
     use error::silence_errors;
-    use handle::ID;
+    use object::ObjectID;
     use test::with_tmp_file;
-    use super::Container;
-    use location::Location;
 
     #[test]
     pub fn test_group() {

hdf5-rs/src/dataset.rs

@@ -11,13 +11,13 @@ use ffi::h5p::{
 };
 use globals::H5P_LINK_CREATE;
 
-use container::Container;
-use datatype::{Datatype, ToDatatype, AnyDatatype};
+use container::ContainerType;
+use datatype::{Datatype, ToDatatype};
 use error::Result;
 use filters::Filters;
-use handle::{Handle, ID, FromID, get_id_type};
-use location::Location;
-use object::Object;
+use handle::Handle;
+use location::LocationType;
+use object::{Object, ObjectType, AllowTypes, ObjectDetail, ObjectID};
 use plist::PropertyList;
 use space::{Dataspace, Dimension, Ix};
 use util::to_cstring;
@@ -34,44 +34,31 @@ pub enum Chunk {
     Manual(Vec<Ix>)
 }
 
-/// Represents the HDF5 dataset object.
-pub struct Dataset {
-    handle: Handle,
+pub struct DatasetID {
     dcpl: PropertyList,
     filters: Filters,
 }
 
-#[doc(hidden)]
-impl ID for Dataset {
-    fn id(&self) -> hid_t {
-        self.handle.id()
+impl ObjectType for DatasetID {
+    fn allow_types() -> AllowTypes {
+        AllowTypes::Just(H5I_DATASET)
     }
-}
 
-#[doc(hidden)]
-impl FromID for Dataset {
-    fn from_id(id: hid_t) -> Result<Dataset> {
-        h5lock!({
-            match get_id_type(id) {
-                H5I_DATASET => {
-                    let handle = Handle::new(id)?;
-                    let dcpl = PropertyList::from_id(h5try!(H5Dget_create_plist(id)))?;
-                    let filters = Filters::from_dcpl(&dcpl)?;
-                    Ok(Dataset {
-                        handle: handle,
-                        dcpl: dcpl,
-                        filters: filters,
-                    })
-                },
-                _ => Err(From::from(format!("Invalid property list id: {}", id))),
-            }
-        })
+    fn from_id(id: hid_t) -> Result<DatasetID> {
+        let dcpl = PropertyList::from_id(h5try!(H5Dget_create_plist(id)))?;
+        let filters = Filters::from_dcpl(&dcpl)?;
+        Ok(DatasetID {dcpl: dcpl, filters: filters })
+    }
+
+    fn type_name() -> &'static str {
+        "file"
     }
 }
 
-impl Object for Dataset {}
+impl LocationType for DatasetID {}
 
-impl Location for Dataset {}
+/// Represents the HDF5 dataset object.
+pub type Dataset = Object<DatasetID>;
 
 impl Dataset {
     /// Returns the shape of the dataset.
@@ -103,7 +90,7 @@ impl Dataset {
 
     /// Returns whether this dataset has a chunked layout.
     pub fn is_chunked(&self) -> bool {
-        h5lock!(H5Pget_layout(self.dcpl.id()) == H5D_layout_t::H5D_CHUNKED)
+        h5lock!(H5Pget_layout(self.detail().dcpl.id()) == H5D_layout_t::H5D_CHUNKED)
     }
 
     /// Returns whether this dataset's type is equivalent to the given type.
@@ -125,7 +112,7 @@ impl Dataset {
                     let ndim = self.ndim();
                     let mut dims: Vec<hsize_t> = Vec::with_capacity(ndim);
                     dims.set_len(ndim);
-                    H5Pget_chunk(self.dcpl.id(), ndim as c_int, dims.as_mut_ptr());
+                    H5Pget_chunk(self.detail().dcpl.id(), ndim as c_int, dims.as_mut_ptr());
                     dims.iter().map(|&x| x as Ix).collect()
                 })
             } else {
@@ -136,14 +123,14 @@ impl Dataset {
 
     /// Returns the filters used to create the dataset.
     pub fn filters(&self) -> Filters {
-        self.filters.clone()
+        self.detail().filters.clone()
     }
 
     /// Returns `true` if object modification time is tracked by the dataset.
     pub fn tracks_times(&self) -> bool {
         unsafe {
             let track_times: *mut hbool_t = &mut 0;
-            h5lock!(H5Pget_obj_track_times(self.dcpl.id(), track_times));
+            h5lock!(H5Pget_obj_track_times(self.detail().dcpl.id(), track_times));
             *track_times == 1
         }
     }
@@ -167,14 +154,14 @@ impl Dataset {
     pub fn fill_value<T: ToDatatype>(&self) -> Result<Option<T>> {
         h5lock!({
             let defined: *mut H5D_fill_value_t = &mut H5D_fill_value_t::H5D_FILL_VALUE_UNDEFINED;
-            h5try!(H5Pfill_value_defined(self.dcpl.id(), defined));
+            h5try!(H5Pfill_value_defined(self.detail().dcpl.id(), defined));
             match *defined {
                 H5D_fill_value_t::H5D_FILL_VALUE_ERROR => fail!("Invalid fill value"),
                 H5D_fill_value_t::H5D_FILL_VALUE_UNDEFINED => Ok(None),
                 _ => {
                     let datatype = T::to_datatype()?;
                     let buf: *mut c_void = libc::malloc(datatype.size() as size_t);
-                    h5try!(H5Pget_fill_value(self.dcpl.id(), datatype.id(), buf));
+                    h5try!(H5Pget_fill_value(self.detail().dcpl.id(), datatype.id(), buf));
                     let result = Ok(Some(T::from_raw_ptr(buf)));
                     libc::free(buf);
                     result
@@ -205,7 +192,7 @@ pub struct DatasetBuilder<T> {
 
 impl<T: ToDatatype> DatasetBuilder<T> {
     /// Create a new dataset builder and bind it to the parent container.
-    pub fn new<C: Container>(parent: &C) -> DatasetBuilder<T> {
+    pub fn new<C: ContainerType>(parent: &Object<C>) -> DatasetBuilder<T> {
         h5lock!({
             // Store the reference to the parent handle and try to increase its reference count.
             let handle = Handle::new(parent.id());
@@ -433,13 +420,10 @@ pub mod tests {
     use ffi::h5d::H5Dwrite;
     use ffi::h5s::H5S_ALL;
     use ffi::h5p::H5P_DEFAULT;
-    use container::Container;
     use datatype::ToDatatype;
     use file::File;
     use filters::{Filters, gzip_available, szip_available};
-    use handle::ID;
-    use location::Location;
-    use object::Object;
+    use object::ObjectID;
     use test::{with_tmp_file, with_tmp_path};
     use libc::c_void;
     use std::io::Read;