Skip to main content
Version: 0.14

Type Registration

This page covers type registration methods in Apache Fory™ Rust.

Register by ID​

Register types with a numeric ID for fast, compact serialization:

use fory::Fory;
use fory::ForyObject;

#[derive(ForyObject)]
struct User {
    name: String,
    age: i32,
}

let mut fory = Fory::default();
fory.register::<User>(1)?;

let user = User {
    name: "Alice".to_string(),
    age: 30,
};

let bytes = fory.serialize(&user)?;
let decoded: User = fory.deserialize(&bytes)?;

Register by Namespace​

For cross-language compatibility, register with namespace and type name:

let mut fory = Fory::default()
    .compatible(true)
    .xlang(true);

// Register with namespace-based naming
fory.register_by_namespace::<MyStruct>("com.example", "MyStruct");

Register Custom Serializer​

For types that need custom serialization logic:

let mut fory = Fory::default();
fory.register_serializer::<CustomType>(100);

Registration Order​

When using ID-based registration without explicit IDs, the registration order matters. Ensure consistent registration order between serialization and deserialization:

// Serializer side
let mut fory = Fory::default();
fory.register::<TypeA>(1)?;
fory.register::<TypeB>(2)?;
fory.register::<TypeC>(3)?;

// Deserializer side - MUST use same order
let mut fory = Fory::default();
fory.register::<TypeA>(1)?;
fory.register::<TypeB>(2)?;
fory.register::<TypeC>(3)?;

Thread-Safe Registration​

Perform all registrations before spawning threads:

use std::sync::Arc;
use std::thread;

let mut fory = Fory::default();
fory.register::<User>(1)?;
fory.register::<Order>(2)?;

// Now share across threads
let fory = Arc::new(fory);

let handles: Vec<_> = (0..4)
    .map(|_| {
        let shared = Arc::clone(&fory);
        thread::spawn(move || {
            // Use fory for serialization
        })
    })
    .collect();

Best Practices​

  1. Use consistent IDs: Same type ID across all languages for cross-language compatibility
  2. Register before threading: Complete all registrations before spawning threads
  3. Use namespace for xlang: Makes type names consistent across languages
  4. Explicit IDs for stability: Avoid auto-generated IDs in production