You are an expert in writing code in many different languages. Your goal is to perform code completion for the following code, keeping in mind the rest of the code and the file meta data.
    Metadata details:
    filename: core.rs
    path of file: ./repos/fluvio/crates/fluvio-stream-model/src
    
    the code of the file until where you have to start completion: pub use core_model::*;
pub use context::*;

mod c
    
        fn set_owner(&mut self, _owner: Self) {}

        fn children(&self) -> Option<&HashMap<String, Vec<Self>>> {
            Default::default()
        }

        fn set_children(&mut self, _children: HashMap<String, Vec<Self>>) {}
    }

    pub trait MetadataRevExtension: MetadataItem {
        // return next revision
        fn next_rev(&self) -> Self;
    }

    impl MetadataItem for u32 {
        type UId = u32;

        fn uid(&self) -> &Self::UId {
            self
        }

        fn is_newer(&self, another: &Self) -> bool {
            self > another
        }
    }

    impl MetadataItem for u64 {
        type UId = u64;

        fn uid(&self) -> &Self::UId {
            self
        }

        fn is_newer(&self, another: &Self) -> bool {
            self > another
        }
    }

    #[derive(Default, Debug, Clone, Eq, PartialEq)]
    pub struct MetadataContext<C> {
        item: C,
    }

    impl<C> From<C> for MetadataContext<C> {
        fn from(item: C) -> Self {
            Self { item }
        }
    }

    impl<C> MetadataContext<C> {
        pub fn new(item: C) -> Self {
            Self::from(item)
        }

        pub fn item(&self) -> &C {
            &self.item
        }

        pub fn item_mut(&mut self) -> &mut C {
            &mut self.item
        }

        pub fn set_item(&mut self, item: C) {
            self.item = item;
        }

        pub fn item_owned(self) -> C {
            self.item
        }

        pub fn into_inner(self) -> C {
            self.item
        }
    }

    impl<C> MetadataContext<C>
    where
        C: MetadataItem,
    {
        pub fn create_child(&self) -> Self {
            let mut item = C::default();
            item.set_owner(self.item().clone());
            Self { item }
        }

        pub fn set_labels<T: Into<String>>(mut self, labels: Vec<(T, T)>) -> Self {
            let item = self.item.set_labels(labels);
            self.item = item;
            self
        }
    }

    impl<C> MetadataContext<C>
    where
        C: MetadataRevExtension,
    {
        pub fn next_rev(&self) -> Self {
            Self::new(self.item.next_rev())
        }
    }

    impl<C> Display for MetadataContext<C>
    where
        C: MetadataItem,
    {
        fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
            write!(f, "{:#?}", self.item)
        }
    }
}