Struct DemoWriter 

pub struct DemoWriter<'a, R, W>
where
    R: BitsReader + MessageReader,
    W: Write + Seek,
{ /* private fields */ }

Demo writer that reads demo messages and writes a rewritten stream.

The writer maintains the parser metadata needed for the registered rewrites, such as serializers, classes, string tables, baselines, and entity state. Output targets must be seekable so the demo header can be patched after writing.

Implementations

impl<'a, R, W> DemoWriter<'a, R, W>

where R: BitsReader + MessageReader, W: Write + Seek,

pub fn run(&mut self) -> Result<(), ParserError>

Parses the demo while writing the rewritten stream.

impl<'a, R, W> DemoWriter<'a, R, W>

where R: BitsReader + MessageReader, W: Write + Seek,

pub fn new(parser: Parser<'a, R>, writer: W) -> Self

Creates a new demo writer from an existing parser and output target.

pub fn add_rewriter<T>(&mut self, rewriter: T) -> Rc<RefCell<T>>

where T: DemoRewriter + 'a,

Adds an already constructed demo rewriter and returns a handle to it.

Use this when the rewriter needs custom constructor state. Rewriters run in registration order; message callbacks see the output of earlier rewriters.

pub fn register_rewriter<T>(&mut self) -> Rc<RefCell<T>>

where T: DemoRewriter + Default + 'a,

Registers a default demo rewriter and returns a handle to it.

This mirrors Parser::register_observer: the writer constructs T::default(), registers it, and returns an Rc<RefCell<T>> so callers can inspect accumulated state after writing.

Examples

#[derive(Default)]
struct RemoveChat;

#[rewriter]
impl RemoveChat {
    #[rewrite_packet_message]
    fn remove_chat(
        &mut self,
        _message: CDotaUserMsgChatMessage,
    ) -> Result<MessageRewrite, ParserError> {
        Ok(MessageRewrite::Drop)
    }
}

let mut writer = DemoWriter::from_reader(input, output)?;
writer.register_rewriter::<RemoveChat>();
writer.run()?;

pub fn into_parts(self) -> (Parser<'a, R>, W)

Returns the wrapped parser and output target.

impl<'a, W> DemoWriter<'a, SliceReader<'a>, W>

where W: Write + Seek,

pub fn from_slice(replay: &'a [u8], writer: W) -> Result<Self, ParserError>

Creates a demo writer from replay bytes and an output target.

This is a convenience wrapper around Parser::from_slice and DemoWriter::new.

impl<S, W> DemoWriter<'static, SeekableReader<S>, W>

where S: Read + Seek, W: Write + Seek,

pub fn from_reader(reader: S, writer: W) -> Result<Self, ParserError>

Creates a demo writer from a seekable reader and an output target.

This is a convenience wrapper around Parser::from_reader and DemoWriter::new.