lib.rs

/*
 * Narukami TO - a server software reimplementation for a certain browser tank game.
 * Copyright (c) 2023-2025  Daniil Pryima
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */

mod array;
mod length;
mod optional;
pub mod optional_map;
mod primitives;
pub mod protocol_buffer;
mod vec;

use std::io::{self};

#[cfg(feature = "derive")]
pub use alternativa_protocol_derive::Codec;
pub use array::*;
use chrono::NaiveDateTime;
pub use length::*;
pub use optional::*;
pub use primitives::*;
use thiserror::Error;
pub use vec::*;

use crate::protocol_buffer::ProtocolBuffer;

#[derive(Error, Debug)]
#[error("unknown enum value {0}")]
pub struct EnumVariantError<T>(pub T);

pub trait Codec {
  fn encode(&self, writer: &mut ProtocolBuffer) -> io::Result<()>;
  fn decode(reader: &mut ProtocolBuffer) -> io::Result<Self>
  where
    Self: Sized;
}

impl Codec for String {
  fn encode(&self, writer: &mut ProtocolBuffer) -> io::Result<()> {
    // TODO(Assasans/perf): Get rid of to_vec?
    self.as_bytes().to_vec().encode(writer)
  }

  fn decode(reader: &mut ProtocolBuffer) -> io::Result<Self> {
    Ok(String::from_utf8(Vec::<u8>::decode(reader)?).unwrap()) // TODO(Assasans): Get rid of the unwrap
  }
}

impl Codec for NaiveDateTime {
  fn encode(&self, writer: &mut ProtocolBuffer) -> io::Result<()> {
    // TODO(Assasans/perf): Get rid of to_vec?
    self.timestamp_millis().encode(writer)
  }

  fn decode(reader: &mut ProtocolBuffer) -> io::Result<Self> {
    Ok(NaiveDateTime::from_timestamp_millis(i64::decode(reader)?).unwrap()) // TODO(Assasans): Get rid of the unwrap
  }
}

#[cfg(test)]
mod tests {
  use byteorder::{ReadBytesExt, WriteBytesExt};
  use chrono::NaiveDate;

  use super::*;

  #[test]
  fn test_string() {
    let mut data = ProtocolBuffer::new();
    let value = "Hello, world!".to_owned();
    value.encode(&mut data).unwrap();
    data.rewind();

    assert_eq!(data.optional_map.data, []);
    assert_eq!(data.data.get_ref()[0], 13);
    assert_eq!(&data.data.get_ref()[1..], b"Hello, world!");
    assert_eq!(String::decode(&mut data).unwrap(), value);
  }

  #[test]
  fn test_date_time() {
    let mut data = ProtocolBuffer::new();
    let value = NaiveDate::from_ymd_opt(2019, 12, 21)
      .unwrap()
      .and_hms_opt(18, 0, 0)
      .unwrap();
    value.encode(&mut data).unwrap();
    data.rewind();

    assert_eq!(data.optional_map.data, []);
    assert_eq!(data.data.get_ref(), &value.timestamp_millis().to_be_bytes());
    assert_eq!(NaiveDateTime::decode(&mut data).unwrap(), value);
  }

  #[test]
  fn test_read_write() {
    let mut buffer = ProtocolBuffer::new();
    buffer.data.write_u8(1).unwrap();
    buffer.rewind();

    println!("{}", buffer.data.position());
    assert_eq!(buffer.data.read_u8().unwrap(), 1);
  }
}

#[cfg(test)]
#[cfg(feature = "derive")]
mod derive_tests {
  use super::*;

  #[derive(Debug, Eq, PartialEq, Codec)]
  struct NamedCC {
    pub field1: i32,
    pub field2: bool
  }

  #[test]
  fn test_derive_struct_named() {
    let mut data = ProtocolBuffer::new();
    let value = NamedCC {
      field1: 0xffff,
      field2: true
    };
    value.encode(&mut data).unwrap();
    data.rewind();

    assert_eq!(data.optional_map.data, []);
    assert_eq!(data.data.get_ref(), &[0x00, 0x00, 0xff, 0xff, 0x01]);
    assert_eq!(NamedCC::decode(&mut data).unwrap(), value);
  }

  #[derive(Debug, Eq, PartialEq, Codec)]
  struct ArrayNamedCC {
    pub field1: [bool; 3]
  }

  #[test]
  fn test_derive_struct_array_named() {
    let mut data = ProtocolBuffer::new();
    let value = ArrayNamedCC {
      field1: [false, true, false]
    };
    value.encode(&mut data).unwrap();
    data.rewind();

    assert_eq!(data.optional_map.data, []);
    assert_eq!(data.data.get_ref(), &[0x00, 0x01, 0x00]);
    assert_eq!(ArrayNamedCC::decode(&mut data).unwrap(), value);
  }

  #[derive(Debug, Eq, PartialEq, Codec)]
  struct NamedOptionalCC {
    pub field1: Option<i32>,
    pub field2: Option<bool>
  }

  #[test]
  fn test_derive_struct_named_optional() {
    let mut data = ProtocolBuffer::new();
    let value = NamedOptionalCC {
      field1: Some(0xffff),
      field2: None
    };
    value.encode(&mut data).unwrap();
    data.rewind();

    assert_eq!(data.optional_map.data, [0b01000000]);
    assert_eq!(data.data.get_ref(), &[0x00, 0x00, 0xff, 0xff]);
    assert_eq!(NamedOptionalCC::decode(&mut data).unwrap(), value);
  }

  #[derive(Debug, Eq, PartialEq, Codec)]
  struct UnnamedCC(i32, bool);

  #[test]
  fn test_derive_struct_unnamed() {
    let mut data = ProtocolBuffer::new();
    let value = UnnamedCC(0xffff, true);
    value.encode(&mut data).unwrap();
    data.rewind();

    assert_eq!(data.optional_map.data, []);
    assert_eq!(data.data.get_ref(), &[0x00, 0x00, 0xff, 0xff, 0x01]);
    assert_eq!(UnnamedCC::decode(&mut data).unwrap(), value);
  }

  #[derive(Debug, Eq, PartialEq, Codec)]
  struct ArrayUnnamedCC([bool; 3]);

  #[test]
  fn test_derive_struct_array_unnamed() {
    let mut data = ProtocolBuffer::new();
    let value = ArrayUnnamedCC([true, false, false]);
    value.encode(&mut data).unwrap();
    data.rewind();

    assert_eq!(data.optional_map.data, []);
    assert_eq!(data.data.get_ref(), &[0x01, 0x00, 0x00]);
    assert_eq!(ArrayUnnamedCC::decode(&mut data).unwrap(), value);
  }

  #[derive(Debug, Eq, PartialEq, Codec)]
  struct UnnamedGenericCC(Vec<i32>);

  #[test]
  fn test_derive_struct_unnamed_generic() {
    let mut data = ProtocolBuffer::new();
    let value = UnnamedGenericCC(vec![]);
    value.encode(&mut data).unwrap();
    data.rewind();

    assert_eq!(data.optional_map.data, []);
    assert_eq!(data.data.get_ref(), &[0x00]);
    assert_eq!(UnnamedGenericCC::decode(&mut data).unwrap(), value);
  }

  #[derive(Debug, Eq, PartialEq, Codec)]
  struct UnitCC;

  #[test]
  fn test_derive_struct_unit() {
    let mut data = ProtocolBuffer::new();
    let value = UnitCC;
    value.encode(&mut data).unwrap();
    data.rewind();

    assert_eq!(data.optional_map.data, []);
    assert_eq!(data.data.get_ref(), &[]);
    assert_eq!(UnitCC::decode(&mut data).unwrap(), value);
  }

  #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Codec)]
  enum EmptyEnum {}

  #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Codec)]
  #[rustfmt::skip]
  enum TestEnum {
    #[value(1)] Variant1,
    #[value(2)] Variant2,
    #[value(3)] Variant3
  }

  #[test]
  fn test_derive_enum() {
    let mut data = ProtocolBuffer::new();
    let value = TestEnum::Variant2;
    value.encode(&mut data).unwrap();
    data.rewind();

    assert_eq!(data.optional_map.data, []);
    assert_eq!(data.data.get_ref(), &[0x00, 0x00, 0x00, 0x02]);
    assert_eq!(TestEnum::decode(&mut data).unwrap(), value);
  }

  #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Codec)]
  #[value_repr(u8)]
  #[rustfmt::skip]
  enum TestReprEnum {
    #[value(1)] Variant1,
    #[value(2)] Variant2,
    #[value(3)] Variant3
  }

  #[test]
  fn test_derive_enum_repr() {
    let mut data = ProtocolBuffer::new();
    let value = TestReprEnum::Variant2;
    value.encode(&mut data).unwrap();
    data.rewind();

    assert_eq!(data.optional_map.data, []);
    assert_eq!(data.data.get_ref(), &[0x02]);
    assert_eq!(TestReprEnum::decode(&mut data).unwrap(), value);
  }
}