Struct DeclarationPtrFull 

pub struct DeclarationPtrFull;

(De)serializes a DeclarationPtr as the declaration it references.

This makes no attempt to restore the pointers - each value is deserialized into a new DeclarationPtr with a reference count of one.

The shared references can be reconstructed using the ids stored, as before serialization these were unique for each separate instance of T in memory. See DeclarationPtrAsId.

Examples

Serialisation:

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

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

    // serde as also supports nesting
    #[serde_as(as = "Vec<(_,DeclarationPtrFull)>")]
    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![];

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

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

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

let expected_json = json!({
    "declaration": {
        "name": { "User": "a"},
        "kind": {"DecisionVariable": {"domain": {"Int": [{"Bounded": [1,5]}]}, "category":
        "Decision"}},
        "id": 0
    },

    "declarations": [
        [1,{
        "name": { "User": "1"},
        "id": 1,
        "kind": {"DecisionVariable": {"domain": {"Int": [{"Bounded": [1,5]}]},
        "category":"Decision"}},
        }],
        [2,{
        "name": { "User": "2"},
        "id": 2,
        "kind": {"DecisionVariable": {"domain": {"Int": [{"Bounded": [1,5]}]},"category":
        "Decision"}},
        }]
    ],
         
    "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::DeclarationPtrFull,Name,DeclarationKind, DeclarationPtr,Domain,Range, ReturnType};

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

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

let input_json = json!({
    "declaration": {
        "name": { "User": "a"},
        "kind": {"DecisionVariable": {"domain": {"Int": [{"Bounded": [0,5]}]}, "category":
        "Decision"}},
        "id": 10,
    },

    "declarations": [
        [1,{
        "name": { "User": "1"},
        "kind": {"DecisionVariable": {"domain": {"Int": [{"Bounded": [0,5]}]}, "category":
        "Decision"}},
        "id": 11,
        }],
        [2,{
        "name": { "User": "2"},
        "kind": {"DecisionVariable": {"domain": {"Int": [{"Bounded": [0,5]}]}, "category":
        "Decision"}},
        "id": 12,
        }]
    ],
    "c": 3
});


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

assert_eq!(&foo.declaration.name() as &Name,&Name::User("a".into()));
assert_eq!(&foo.declarations[0].1.name() as &Name,&Name::User("1".into()));
assert_eq!(&foo.declarations[1].1.name() as &Name,&Name::User("2".into()));

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

// ids should be the same as in the json
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 DeclarationPtrFull

fn deserialize_as<D>( deserializer: D, ) -> Result<DeclarationPtr, <D as Deserializer<'de>>::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl SerializeAs<DeclarationPtr> for DeclarationPtrFull

fn serialize_as<S>( source: &DeclarationPtr, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::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