Crate durian::durian_macros
source · Expand description
Macros for the durian crate
Procedural Macros
Procedural macros for easily annotating structs as Packets
and automatically
implementing PacketBuilders
. The only
requirement is the struct must be de/serializable, meaning all nested fields also need to be
de/serializable.
#[bincode_packet]
will de/serialize your Packet using bincode
and applies necessary derive
macros automatically for you.
use durian::bincode_packet;
// Automatically implements Packet, and generates a PositionPacketBuilder that implements
// PacketBuilder. You can also add other macros such as derive macros so long s they don't
// conflict with what #[bincode_packet] adds (See bincode_packet documentation).
#[bincode_packet]
#[derive(Debug)]
struct Position {
x: i32,
y: i32
}
// Works for Unit (empty) structs as well
#[bincode_packet]
struct Ack;
You can also use the derive macros (BinPacket
and UnitPacket
) manually:
use durian::serde::{Deserialize, Serialize};
use durian::{BinPacket, UnitPacket};
#[derive(Serialize, Deserialize, BinPacket)]
#[serde(crate = "durian::serde")]
struct Position { x: i32, y: i32 }
#[derive(UnitPacket)]
struct Ack;
Declarative Macros
Regular macros for easy and concise calls to the PacketManager
.
These include macros for registering all your send
and receive
packets:
register_send!(packet_manager, <send packets>...)
register_receive!(packet_manager, <receive packets>...)
Where the <send packets>
a sequence of your send
packet types, or a slice of those types, and
<receive packets>
are a sequence of tuples containing (your receive
packet type, the associated packet builder),
or a slice of those tuples.
Example:
use durian::{bincode_packet, register_send, register_receive, PacketManager};
// Send packets
#[bincode_packet]
struct Position { x: i32, y: i32 }
#[bincode_packet]
struct Ack;
// Receive packets
#[bincode_packet]
struct UpdatePosition { x: i32, y: i32 }
#[bincode_packet]
struct NewMessage { message: String }
fn main() {
let mut manager = PacketManager::new();
let register_receive_results = register_receive!(
manager,
(UpdatePosition, UpdatePositionPacketBuilder),
(NewMessage, NewMessagePacketBuilder)
);
// Or equivalently in a slice,
// register_receive_results!(manager,
// [(UpdatePosition, UpdatePositionPacketBuilder), (NewMessage, NewMessagePacketBuilder)]
// );`
let register_send_results = register_send!(manager, Position, Ack);
// Or equivalently in a slice, `register_send!(manager, [Position, Ack]);`
// You can then validate that all the registrations were successful:
assert!(register_receive_results.iter().all(|r| r.is_ok()));
assert!(register_send_results.iter().all(|r| r.is_ok()));
// The macros used above are equivalent to the following manual registration:
//
// manager.register_receive_packet::<UpdatePosition>(UpdatePositionPacketBuilder);
// manager.register_receive_packet::<NewMessage>(NewMessagePacketBuilder);
// manager.register_send_packet::<Position>();
// manager.register_send_packet::<Ack>();
}
Macros
Attribute Macros
- Macros for easy creation of
Packets
andPacketBuilders
Derive Macros
- derive macro to automatically implement
Packet
andPacketBuilder
for a struct. - Convenience derive macro that implements [
Deref
] and [DerefMut
] for a struct that contains amanager: PacketManager
field. - Implements a
new()
function for a struct that contains only amessage: String
field - Same as
BinPacket
but for empty or Unit structs