Define Binary Protocols Once, Generate Everywhere

import { BitStreamEncoder, Endianness } from "./bit-stream.js";
import { SeekableBitStreamDecoder } from "./seekable-bit-stream.js";
import { createReader } from "./binary-reader.js";

export interface SensorReadingInput {
  /** 16-bit Unsigned Integer */
  device_id: number;
  /** 32-bit Floating Point (IEEE 754) */
  temperature: number;
  /** 8-bit Unsigned Integer */
  humidity: number;
  /** 32-bit Unsigned Integer */
  timestamp: number;
}

export interface SensorReadingOutput {
  device_id: number;
  temperature: number;
  humidity: number;
  timestamp: number;
}

export type SensorReading = SensorReadingOutput;

export class SensorReadingEncoder extends BitStreamEncoder {
  constructor() {
    super("msb_first");
  }

  encode(value: SensorReadingInput): Uint8Array {
    this.writeUint16(value.device_id, "big_endian");
    this.writeFloat32(value.temperature, "big_endian");
    this.writeUint8(value.humidity);
    this.writeUint32(value.timestamp, "big_endian");
    return this.finish();
  }

  calculateSize(value: SensorReading): number {
    let size = 0;
    size += 2; // device_id
    size += 4; // temperature
    size += 1; // humidity
    size += 4; // timestamp
    return size;
  }
}

export class SensorReadingDecoder extends SeekableBitStreamDecoder {
  constructor(input: Uint8Array | number[] | string) {
    const reader = createReader(input);
    super(reader, "msb_first");
  }

  decode(): SensorReadingOutput {
    return {
      device_id: this.readUint16("big_endian"),
      temperature: this.readFloat32("big_endian"),
      humidity: this.readUint8(),
      timestamp: this.readUint32("big_endian"),
    };
  }
}

package main

import (
    "fmt"
    "github.com/serialexp/binschema/runtime"
)

type SensorReading struct {
    DeviceId    uint16
    Temperature float32
    Humidity    uint8
    Timestamp   uint32
}

func (m *SensorReading) Encode() ([]byte, error) {
    encoder := runtime.NewBitStreamEncoder(runtime.MSBFirst)
    encoder.WriteUint16(m.DeviceId, runtime.BigEndian)
    encoder.WriteFloat32(m.Temperature, runtime.BigEndian)
    encoder.WriteUint8(m.Humidity)
    encoder.WriteUint32(m.Timestamp, runtime.BigEndian)
    return encoder.Finish(), nil
}

func DecodeSensorReading(bytes []byte) (*SensorReading, error) {
    decoder := runtime.NewBitStreamDecoder(bytes, runtime.MSBFirst)
    result := &SensorReading{}

    deviceId, err := decoder.ReadUint16(runtime.BigEndian)
    if err != nil {
        return nil, fmt.Errorf("failed to decode device_id: %w", err)
    }
    result.DeviceId = deviceId

    temperature, err := decoder.ReadFloat32(runtime.BigEndian)
    if err != nil {
        return nil, fmt.Errorf("failed to decode temperature: %w", err)
    }
    result.Temperature = temperature

    humidity, err := decoder.ReadUint8()
    if err != nil {
        return nil, fmt.Errorf("failed to decode humidity: %w", err)
    }
    result.Humidity = humidity

    timestamp, err := decoder.ReadUint32(runtime.BigEndian)
    if err != nil {
        return nil, fmt.Errorf("failed to decode timestamp: %w", err)
    }
    result.Timestamp = timestamp

    return result, nil
}

use binschema_runtime::{
    BitStreamEncoder, BitStreamDecoder,
    Endianness, BitOrder, Result,
};

#[derive(Debug, Clone, PartialEq)]
pub struct SensorReadingInput {
    pub device_id: u16,
    pub temperature: f32,
    pub humidity: u8,
    pub timestamp: u32,
}

#[derive(Debug, Clone, PartialEq)]
pub struct SensorReadingOutput {
    pub device_id: u16,
    pub temperature: f32,
    pub humidity: u8,
    pub timestamp: u32,
}

pub type SensorReading = SensorReadingOutput;

impl SensorReadingInput {
    pub fn encode(&self) -> Result<Vec<u8>> {
        let mut encoder = BitStreamEncoder::new(BitOrder::MsbFirst);
        encoder.write_uint16(self.device_id, Endianness::BigEndian);
        encoder.write_float32(self.temperature, Endianness::BigEndian);
        encoder.write_uint8(self.humidity);
        encoder.write_uint32(self.timestamp, Endianness::BigEndian);
        Ok(encoder.finish())
    }
}

impl SensorReadingOutput {
    pub fn decode(bytes: &[u8]) -> Result<Self> {
        let mut decoder = BitStreamDecoder::new(
            bytes.to_vec(), BitOrder::MsbFirst
        );
        let device_id = decoder.read_uint16(Endianness::BigEndian)?;
        let temperature = decoder.read_float32(Endianness::BigEndian)?;
        let humidity = decoder.read_uint8()?;
        let timestamp = decoder.read_uint32(Endianness::BigEndian)?;
        Ok(Self {
            device_id,
            temperature,
            humidity,
            timestamp,
        })
    }
}