pub fn new() -> Result<Self> {

        Self::with_output_size(DEFAULT_OUTPUT_SIZE)

    }

    pub fn with_output_size(output_size: u32) -> Result<Self> {

        let input = InputReader::new()?;

        let output = OutputWriter::new(input.entity_count(), output_size);

        Ok(Self { input, output })

    }

    pub fn context_type(&self) -> Result<ContextType> {

        self.input.context_type()

    }

    pub fn primary_entity_type(&self) -> Result<EntityType> {

        self.input.primary_entity_type()

    }

    pub fn entity_count(&self) -> u32 {

        self.input.entity_count()

    }

    pub fn primary_entity_idx(&self) -> u32 {

        self.input.primary_entity_idx()

    }

    pub fn entity(&self, idx: u32) -> Result<EntityRef<'_>> {

        self.input.entity(idx)

    }

    pub fn primary(&self) -> Result<EntityRef<'_>> {

        self.input.primary()

    }

    pub fn primary_transaction(&self) -> Result<Transaction> {

        self.input.primary_transaction()

    }

    pub fn transaction(&self, idx: u32) -> Result<Transaction> {

        self.input.transaction(idx)

    }

    pub fn split(&self, idx: u32) -> Result<Split> {

        self.input.split(idx)

    }

    pub fn tag(&self, idx: u32) -> Result<Tag<'_>> {

        self.input.tag(idx)

    }

    pub fn splits_for(&self, parent_idx: u32) -> impl Iterator<Item = Result<Split>> + '_ {

        self.input.splits_for(parent_idx)

    }

    pub fn tags_for(&self, parent_idx: u32) -> impl Iterator<Item = Result<Tag<'_>>> + '_ {

        self.input.tags_for(parent_idx)

    }

    pub fn create_tag(&mut self, parent_idx: i32, name: &str, value: &str) -> Result<u32> {

        self.output.create_tag(parent_idx, name, value)

    }

    pub fn tag_primary(&mut self, name: &str, value: &str) -> Result<u32> {

        let primary_idx = self.input.primary_entity_idx() as i32;

        self.output.create_tag(primary_idx, name, value)

    }

    pub fn delete_entity(&mut self, entity_id: [u8; 16], entity_type: EntityType) -> Result<u32> {

        self.output.delete_entity(entity_id, entity_type)

    }

    pub fn finalize(self) -> Result<()> {

        self.output.finalize()

    }

    pub fn output_entity_count(&self) -> u32 {

        self.output.entity_count()

    }