Struct DeclarationPtrAsId 

pub struct DeclarationPtrAsId;

(De)serializes a DeclarationPtr as its id.

On deserialization, each declaration is re-created with default dummy values, except for the id, which will be the same as the original declaration.

It is left to the user to fix these values before use. Before serialization, each object in memory has a unique id; using this information, re-constructing the shared pointers should be possible, as long as the contents of each object were also stored, e.g. with DeclarationPtrFull.

Examples

Serialisation:

use serde::Serialize;
use serde_json::json;
use serde_with::serde_as;
use conjure_cp_core::ast::{declaration::serde::DeclarationPtrAsId,Name,DeclarationPtr,Domain,Range};

// some struct containing a DeclarationPtr.
#[serde_as]
#[derive(Clone,PartialEq,Eq,Serialize)]
struct Foo {
    #[serde_as(as = "DeclarationPtrAsId")]
    declaration: DeclarationPtr,

    // serde as also supports nesting
    #[serde_as(as = "Vec<(_,DeclarationPtrAsId)>")]
    declarations: Vec<(i32,DeclarationPtr)>,

    c: i32
}

let declaration = DeclarationPtr::new_var(Name::User("a".into()),Domain::Int(vec![Range::Bounded(1,5)]));
let mut declarations: Vec<(i32,DeclarationPtr)>  = vec![];
for i in (1..=2) {
    declarations.push((i,DeclarationPtr::new_var(Name::User(format!("{i}").into()),Domain::Int(vec![Range::Bounded(1,5)]))));
}

let foo = Foo {
    declaration,
    declarations,
    c: 3
};

let json = serde_json::to_value(foo).unwrap();

let expected_json = json!({
    "declaration": 0,
    "declarations": [(1,1),(2,2)],
    "c": 3
});

assert_eq!(json,expected_json);

Deserialisation:

use serde::Deserialize;
use serde_json::json;
use serde_with::serde_as;
use conjure_cp_core::ast::{serde::{HasId},declaration::serde::DeclarationPtrAsId,Name,DeclarationKind, DeclarationPtr,Domain,Range, ReturnType};

// some struct containing a DeclarationPtr.
#[serde_as]
#[derive(Clone,PartialEq,Eq,Deserialize)]
struct Foo {
    #[serde_as(as = "DeclarationPtrAsId")]
    declaration: DeclarationPtr,

    // serde as also supports nesting
    #[serde_as(as = "Vec<(_,DeclarationPtrAsId)>")]
    declarations: Vec<(i32,DeclarationPtr)>,
    c: i32
}

let input_json = json!({
    "declaration": 10,
    "declarations": [(11,11),(12,12)],
    "c": 3
});


let foo: Foo = serde_json::from_value(input_json).unwrap();


// all declarations should have the dummy values: name: User("_UNKNOWN"), kind: value_letting;
assert_eq!(&foo.declaration.name() as &Name,&Name::User("_UNKNOWN".into()));
assert_eq!(&foo.declarations[0].1.name() as &Name,&Name::User("_UNKNOWN".into()));
assert_eq!(&foo.declarations[1].1.name() as &Name,&Name::User("_UNKNOWN".into()));

assert!(matches!(&foo.declaration.kind() as &DeclarationKind,&DeclarationKind::ValueLetting(_)));
assert!(matches!(&foo.declarations[0].1.kind() as &DeclarationKind,&DeclarationKind::ValueLetting(_)));
assert!(matches!(&foo.declarations[1].1.kind() as &DeclarationKind,&DeclarationKind::ValueLetting(_)));

// but ids should be the same

assert_eq!(*&foo.declaration.id(),10);
assert_eq!(*&foo.declarations[0].1.id(),11);
assert_eq!(*&foo.declarations[1].1.id(),12);

Trait Implementations

impl<'de> DeserializeAs<'de, DeclarationPtr> for DeclarationPtrAsId

fn deserialize_as<D>(deserializer: D) -> Result<DeclarationPtr, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl SerializeAs<DeclarationPtr> for DeclarationPtrAsId

fn serialize_as<S>( source: &DeclarationPtr, serializer: S, ) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 0 bytes