subcmd: SubCommand,

    subcmd: Option<SubCommand>,

            SubCommand::Create {

            Some(SubCommand::Create {

            } => {

            }) => {

            SubCommand::Checkout { tag, to_channel } => {

            Some(SubCommand::Checkout { tag, to_channel }) => {

                writeln!(stdout, "Tag {} restored as channel {}", tag, channel_name)?;

            None => {
                let channel_name = repo
                    .config
                    .get_current_channel(None)
                    .0
                    .to_string();
                let txn = repo.pristine.txn_begin()?;
                let channel = if let Some(c) = txn.load_channel(&channel_name)? {
                    c
                } else {
                    bail!("Channel {:?} not found", channel_name)
                };
                let mut tag_path = repo.path.join(libpijul::DOT_DIR);
                tag_path.push("tags");
                super::pager();
                for t in txn.rev_iter_tags(txn.tags(&*channel.read()?), None)? {
                    let (_, h) = t?;
                    let h: libpijul::Hash = h.into();
                    libpijul::changestore::filesystem::push_filename(&mut tag_path, &h);
                    let mut f = libpijul::tag::OpenTagFile::open(&tag_path)?;
                    let header = f.header()?;
                    writeln!(stdout, "Tag {}", h.to_base32())?;
                    writeln!(stdout, "Author: {:?}", header.authors)?;
                    writeln!(stdout, "Date: {}", header.timestamp)?;
                    writeln!(stdout, "State: {}", f.state().to_base32())?;
                    writeln!(stdout, "\n    {}\n", header.message)?;
                }
            }

                debug!("t = {:?}", t.name());

    }
    pub fn header(&mut self) -> Result<crate::change::ChangeHeader, TagError> {
        use std::io::{Seek, SeekFrom};
        self.file.seek(SeekFrom::Start(self.header.header))?;
        Ok(bincode::deserialize_from(&mut self.file)?)

    pub fn state(&self) -> Merkle {
        self.header.state.clone()
    }

    fn tags<'a>(&self, channel: &'a Self::Channel) -> &'a Self::Tags {
        &channel.tags
    }

    fn iter_tags(
        &self,
        channel: &Self::Tags,
        from: u64,
    ) -> Result<
        super::Cursor<Self, &Self, Self::TagsCursor, L64, SerializedHash>,
        TxnErr<Self::GraphError>,
    > {
        self.cursor_tags(channel, Some(from.into()))
    }
    fn rev_iter_tags(
        &self,
        channel: &Self::Tags,
        from: Option<u64>,
    ) -> Result<
        super::RevCursor<Self, &Self, Self::TagsCursor, L64, SerializedHash>,
        TxnErr<Self::GraphError>,
    > {
        let mut cursor = btree::cursor::Cursor::new(&self.txn, channel)?;
        if let Some(from) = from {
            cursor.set(&self.txn, &from.into(), None)?;
        } else {
            cursor.set_last(&self.txn)?;
        };
        Ok(RevCursor {
            cursor,
            txn: self,
            k: std::marker::PhantomData,
            v: std::marker::PhantomData,
            t: std::marker::PhantomData,
        })
    }

    fn tags<'a>(&self, channel: &'a Self::Channel) -> &'a Self::Tags;

    fn iter_tags(
        &self,
        channel: &Self::Tags,
        from: u64,
    ) -> Result<
        Cursor<Self, &Self, Self::TagsCursor, L64, SerializedHash>,
        TxnErr<Self::GraphError>,
    >;
    fn rev_iter_tags(
        &self,
        channel: &Self::Tags,
        from: Option<u64>,
    ) -> Result<
        RevCursor<Self, &Self, Self::TagsCursor, L64, SerializedHash>,
        TxnErr<Self::GraphError>,
    >;

// #[cfg(debug_assertions)]

initialized_cursor!(tags, L64, SerializedHash, ChannelTxnT, GraphError);
initialized_rev_cursor!(tags, L64, SerializedHash, ChannelTxnT, GraphError);