[Rust] Move `BinaryReader` and `BinaryWriter` into `binary_view` module

Both of these are associated directly to a `BinaryView` and only exist as accessors onto it.

1 files changed, 0 insertions, 151 deletions

diff --git a/rust/src/binary_writer.rs b/rust/src/binary_writer.rs
deleted file mode 100644
index 176a54d8..00000000
--- a/rust/src/binary_writer.rs
+++ /dev/null
@@ -1,151 +0,0 @@
-// Copyright 2022-2025 Vector 35 Inc.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-//! A convenience class for writing binary data
-
-use binaryninjacore_sys::*;
-use std::fmt::Debug;
-
-use crate::binary_view::{BinaryView, BinaryViewBase, BinaryViewExt};
-use crate::Endianness;
-
-use crate::rc::Ref;
-use std::io::{ErrorKind, Seek, SeekFrom, Write};
-
-pub struct BinaryWriter {
-    view: Ref<BinaryView>,
-    handle: *mut BNBinaryWriter,
-}
-
-impl BinaryWriter {
-    pub fn new(view: &BinaryView) -> Self {
-        let handle = unsafe { BNCreateBinaryWriter(view.handle) };
-        Self {
-            view: view.to_owned(),
-            handle,
-        }
-    }
-
-    pub fn new_with_opts(view: &BinaryView, options: &BinaryWriterOptions) -> Self {
-        let mut writer = Self::new(view);
-        if let Some(endianness) = options.endianness {
-            writer.set_endianness(endianness);
-        }
-        if let Some(address) = options.address {
-            writer.seek_to_offset(address);
-        }
-        writer
-    }
-
-    pub fn endianness(&self) -> Endianness {
-        unsafe { BNGetBinaryWriterEndianness(self.handle) }
-    }
-
-    pub fn set_endianness(&mut self, endianness: Endianness) {
-        unsafe { BNSetBinaryWriterEndianness(self.handle, endianness) }
-    }
-
-    pub fn seek_to_offset(&mut self, offset: u64) {
-        unsafe { BNSeekBinaryWriter(self.handle, offset) }
-    }
-
-    pub fn seek_to_relative_offset(&mut self, offset: i64) {
-        unsafe { BNSeekBinaryWriterRelative(self.handle, offset) }
-    }
-
-    pub fn offset(&self) -> u64 {
-        unsafe { BNGetWriterPosition(self.handle) }
-    }
-}
-
-impl Debug for BinaryWriter {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.debug_struct("BinaryWriter")
-            .field("offset", &self.offset())
-            .field("endianness", &self.endianness())
-            .finish()
-    }
-}
-
-impl Seek for BinaryWriter {
-    /// Seek to the specified position.
-    fn seek(&mut self, pos: SeekFrom) -> std::io::Result<u64> {
-        match pos {
-            SeekFrom::Current(offset) => self.seek_to_relative_offset(offset),
-            SeekFrom::Start(offset) => self.seek_to_offset(offset),
-            SeekFrom::End(end_offset) => {
-                let view_end = self.view.original_image_base() + self.view.len();
-                let offset = view_end
-                    .checked_add_signed(end_offset)
-                    .ok_or(std::io::Error::new(
-                        ErrorKind::Other,
-                        "Seeking from end overflowed",
-                    ))?;
-                self.seek_to_offset(offset);
-            }
-        };
-
-        Ok(self.offset())
-    }
-}
-
-impl Write for BinaryWriter {
-    fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
-        let len = buf.len();
-        let result = unsafe { BNWriteData(self.handle, buf.as_ptr() as *mut _, len) };
-        if !result {
-            Err(std::io::Error::new(
-                std::io::ErrorKind::Other,
-                "write out of bounds",
-            ))
-        } else {
-            Ok(len)
-        }
-    }
-
-    fn flush(&mut self) -> std::io::Result<()> {
-        Ok(())
-    }
-}
-
-impl Drop for BinaryWriter {
-    fn drop(&mut self) {
-        unsafe { BNFreeBinaryWriter(self.handle) }
-    }
-}
-
-unsafe impl Sync for BinaryWriter {}
-unsafe impl Send for BinaryWriter {}
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default)]
-pub struct BinaryWriterOptions {
-    endianness: Option<Endianness>,
-    address: Option<u64>,
-}
-
-impl BinaryWriterOptions {
-    pub fn new() -> Self {
-        Self::default()
-    }
-
-    pub fn with_endianness(mut self, endian: Endianness) -> Self {
-        self.endianness = Some(endian);
-        self
-    }
-
-    pub fn with_address(mut self, address: u64) -> Self {
-        self.address = Some(address);
-        self
-    }
-}