init

.gitignore

@@ -0,0 +1 @@
+/target

Cargo.toml

@@ -0,0 +1,16 @@
+[package]
+name = "odrlpublic"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+serde_json = "1.0.111"
+serde = { version = "1.0.195", features = ["derive"] }
+uuid = { version = "1.7.0", features = ["v4"] }
+url = "2.5.0"
+lazy_static = "1.4.0"
+sophia = "0.8.0"
+sophia_jsonld = "0.8.0"
+sophia_term = "0.8.0"

src/NameSpaces.rs

@@ -0,0 +1,12 @@
+pub const RDF_NS: &'static str = "http://www.w3.org/1999/02/22-rdf-syntax-ns#";
+pub const RDFS_NS: &'static str = "http://www.w3.org/2000/01/rdf-schema#";
+pub const OWL_NS: &'static str = "http://www.w3.org/2002/07/owl#";
+pub const XSD_NS: &'static str = "http://www.w3.org/2001/XMLSchema#";
+pub const SKOS_NS: &'static str = "http://www.w3.org/2004/02/skos/core#";
+pub const DCTERMS_NS: &'static str = "http://purl.org/dc/terms/";
+pub const VCARD_NS: &'static str = "http://www.w3.org/2006/vcard/ns#";
+pub const FOAF_NS: &'static str = "http://xmlns.com/foaf/0.1/";
+pub const SCHEMA_NS: &'static str = "http://schema.org/";
+pub const CC_NS: &'static str = "https://creativecommons.org/ns#";
+pub const LD_NS: &'static str = "http://www.w3.org/ns/odrl.jsonld#";
+pub const ODRL_NS: &'static str = "http://www.w3.org/ns/odrl/2/";

src/ODRL/Serializer.rs

@@ -0,0 +1,338 @@
+use sophia::api::prelude::*;
+use sophia::api::ns::Namespace;
+use sophia::api::ns::rdf;
+use sophia::api::term::SimpleTerm;
+use sophia::iri::IriRef;
+use sophia::iri::Iri;
+use sophia::inmem::graph::LightGraph;
+use sophia::turtle::serializer::nt::NtSerializer;
+use sophia_jsonld::*;
+use sophia_term::RcTerm;
+
+
+use crate::{model, NameSpaces};
+use model::Action::*;
+use model::Asset::*;
+use model::ConflictTerm::*;
+use model::Constraint::*;
+use model::Party::*;
+use model::Policy::*;
+use model::Rule::*;
+
+use serde_json::Value;
+
+
+fn create_policy() -> Policy {
+
+    let (use_action, _) = Action::init_top_level();
+
+    let simple_asset = Asset::new(
+        Some("http://example.com/asset:9898.movie".to_string()),
+        vec![],
+        Relation::new(None),
+        None
+    );
+
+    let example_permission = Rule::Permission(Permission::new(
+        None,
+        use_action,
+        None,
+        vec![],
+        vec![],
+        vec![],
+        simple_asset,
+        None,
+        None,
+        vec![],
+    ));
+
+    let set_policy = Policy::SetPolicy(
+        SetPolicy::new(
+            "http://example.com/policy:1010".to_string(),
+            vec![example_permission],
+            vec![],
+            vec![],
+            None,
+            None
+        )
+    );
+
+    set_policy
+}
+
+trait Serializable {
+    fn add_to_graph(&self, graph: &mut LightGraph) -> Result<(), Box<dyn std::error::Error>>;
+}
+
+// TODO: Implement Serializable for all ODRL-Model-Types
+impl Serializable for Action {
+    fn add_to_graph(&self, graph: &mut LightGraph) -> Result<(), Box<dyn std::error::Error>> {
+        // TODO
+        Ok(())
+    }
+}
+
+impl Serializable for Asset {
+    fn add_to_graph(&self, graph: &mut LightGraph) -> Result<(), Box<dyn std::error::Error>> {
+        // TODO
+        Ok(())
+    }
+}
+
+impl Serializable for ConflictTerm {
+    fn add_to_graph(&self, graph: &mut LightGraph) -> Result<(), Box<dyn std::error::Error>> {
+        // TODO
+        Ok(())
+    }
+}
+
+impl Serializable for Constraint {
+    fn add_to_graph(&self, graph: &mut LightGraph) -> Result<(), Box<dyn std::error::Error>> {
+        // TODO
+        Ok(())
+    }
+}
+
+impl Serializable for Party {
+    fn add_to_graph(&self, graph: &mut LightGraph) -> Result<(), Box<dyn std::error::Error>> {
+        // TODO
+        Ok(())
+    }
+}
+
+impl Serializable for Obligation {
+    fn add_to_graph(&self, graph: &mut LightGraph) -> Result<(), Box<dyn std::error::Error>> {
+        // TODO
+        Ok(())
+    }
+}
+
+impl Serializable for Policy {
+    fn add_to_graph(&self, graph: &mut LightGraph) -> Result<(), Box<dyn std::error::Error>> {
+        match self {
+            Policy::SetPolicy(set_policy) => set_policy.add_to_graph(graph),
+            Policy::OfferPolicy(offer_policy) => offer_policy.add_to_graph(graph),
+            Policy::AgreementPolicy(agreement_policy) => agreement_policy.add_to_graph(graph),
+        }.expect("Error adding policy to graph since its type is not supported");
+
+        Ok(())
+    }
+}
+
+impl Serializable for SetPolicy {
+    fn add_to_graph(&self, graph: &mut LightGraph) -> Result<(), Box<dyn std::error::Error>> {
+        let set_policy_type = IriRef::new(format!("{}type", NameSpaces::RDF_NS))?;
+        let set_policy_uid = self.uid.clone();
+        let set_policy_term = IriRef::new(set_policy_uid).unwrap();
+
+        // Insert triples for SetPolicy
+        graph.insert(&set_policy_term, &set_policy_type, &IriRef::new(format!("{}Set", NameSpaces::LD_NS)).unwrap())?; // Type
+        graph.insert(&set_policy_term, &IriRef::new(format!("{}uid", NameSpaces::LD_NS)).unwrap(), &set_policy_term)?; // UID
+
+
+        // Insert other triples for fields:
+        //      rules: Vec<Rule>,
+        //      profiles: Vec<IRI>,
+        //      inherit_from: Vec<IRI>,
+        //      conflict: Option<ConflictTerm>,
+        //      obligation: Option<Vec<Obligation>>,
+        for rule in &self.rules {
+            rule.add_to_graph(graph)?;
+            // Rules can be of type Permission, Prohibition, or Duty, therefore their insertion will be handled by the add_to_graph() method.
+        }
+        /* Profiles and inherit_from are represented as IRIs, therefore can be directly added to the graph as object values in triples. */
+        for profile in &self.profiles {
+            graph.insert(&set_policy_term, &IriRef::new(NameSpaces::ODRL_NS).unwrap(), &IriRef::new(profile.to_string()).unwrap())?;
+        }
+        for inherit in &self.inherit_from {
+            graph.insert(&set_policy_term, &IriRef::new(NameSpaces::ODRL_NS).unwrap(), &IriRef::new(inherit.to_string()).unwrap())?;
+        }
+        /* Since ConcflictTerms and Obligations are more complex structures, they may require more than just the IRI to be represented in the graph.
+         Therefore, their insertion will be handled by the add_to_graph() method. */
+        if let Some(conflict) = &self.conflict {
+            conflict.add_to_graph(graph)?;
+        }
+        if let Some(obligations) = &self.obligation {
+            for obligation in obligations {
+                obligation.add_to_graph(graph)?;
+            }
+        }
+        Ok(())
+    }
+}
+
+impl Serializable for OfferPolicy {
+    fn add_to_graph(&self, graph: &mut LightGraph) -> Result<(), Box<dyn std::error::Error>> {
+        // TODO
+        Ok(())
+    }
+}
+
+impl Serializable for AgreementPolicy {
+    fn add_to_graph(&self, graph: &mut LightGraph) -> Result<(), Box<dyn std::error::Error>> {
+        // TODO
+        Ok(())
+    }
+}
+
+impl Serializable for Rule {
+    fn add_to_graph(&self, graph: &mut LightGraph) -> Result<(), Box<dyn std::error::Error>> {
+        match self {
+            Rule::Permission(permission) => permission.add_to_graph(graph),
+            Rule::Prohibition(prohibition) => prohibition.add_to_graph(graph),
+            Rule::Duty(duty) => duty.add_to_graph(graph),
+        }.expect("Error adding rule to graph since its type is not supported");
+        Ok(())
+    }
+}
+
+impl Serializable for Permission {
+    fn add_to_graph(&self, graph: &mut LightGraph) -> Result<(), Box<dyn std::error::Error>> {
+        // Define terms
+        let set_policy_type = IriRef::new(format!("{}Set", NameSpaces::LD_NS))?;
+        let permission_term = IriRef::new(format!("{}_permission", NameSpaces::LD_NS))?;
+        let target_term = IriRef::new(&self.target)?;
+        let action_term = IriRef::new(format!("{}{}", NameSpaces::LD_NS, self.action))?;
+
+        // Insert triples for permission
+        graph.insert(&permission_term, &set_policy_type, &action_term)?;
+        graph.insert(&permission_term, &set_policy_type, &target_term)?;
+
+        Ok(())
+    }
+}
+
+impl Serializable for Prohibition {
+    fn add_to_graph(&self, graph: &mut LightGraph) -> Result<(), Box<dyn std::error::Error>> {
+        // TODO
+        Ok(())
+    }
+}
+
+impl Serializable for Duty {
+    fn add_to_graph(&self, graph: &mut LightGraph) -> Result<(), Box<dyn std::error::Error>> {
+        // TODO
+        Ok(())
+    }
+}
+
+impl Serializable for Agreement {
+    fn add_to_graph(&self, graph: &mut LightGraph) -> Result<(), Box<dyn std::error::Error>> {
+        // TODO
+        Ok(())
+    }
+}
+
+pub fn build_graph<T: Serializable>(odrl_object: &T) -> Result<(), Box<dyn std::error::Error>> {
+
+    // TODO
+    Ok::<(), Box<dyn std::error::Error>>(())
+
+}
+
+pub fn json_ld_from_graph() {
+
+    // TODO
+
+}
+
+pub fn main() -> Result<(), Box<dyn std::error::Error>> {
+
+    let policy = create_policy();
+
+    let mut policy_uid = String::new();
+    let mut policy_type = "";
+    let mut rule_type = "";
+    let mut action_type = String::new();
+    let mut target_uid = String::new();
+
+    if let Policy::SetPolicy(ref policy) = policy {
+        policy_uid = policy.uid.clone();
+        policy_type = "Set";
+        for rule in policy.rules.clone() {
+            match rule {
+                Rule::Permission(Permission {
+                                     uid, action, relation, function, failures,
+                                     constraints, target, assigner, assignee, duties }) => {
+                    rule_type = "permission";
+                    action_type = action.name;
+                    target_uid = target.uid.unwrap_or_else(|| "unknown".to_string());
+                },
+                _ => {
+                    rule_type = "unknown"; // match mit anderen Rule-Typen erstellen
+                }
+            }
+        }
+    }
+
+
+    // Erstellen des RDF-Graphen
+    let mut graph = LightGraph::new();
+
+    // Beispiel-Tripel hinzufügen
+    let policy_uri = IriRef::new("policy").unwrap();
+    let asset_uri = IriRef::new("asset").unwrap();
+    let set_uri = IriRef::new("Set").unwrap();
+    let use_uri = IriRef::new("use").unwrap();
+
+    let policy_id = IriRef::new(policy_uid.clone()).unwrap();
+    let asset_id = IriRef::new(target_uid.clone()).unwrap();
+
+    graph.insert(&policy_id, &rdf::type_, &set_uri).unwrap();
+    graph.insert(&policy_id, &IriRef::new("uid").unwrap(), &policy_id).unwrap();
+    graph.insert(&policy_id, &IriRef::new(rule_type).unwrap(), &asset_id).unwrap();
+    graph.insert(&asset_id, &rdf::type_, &asset_uri).unwrap();
+    graph.insert(&policy_id, &use_uri, &asset_id).unwrap();
+
+    let mut nt_stringifier = NtSerializer::new_stringifier();
+    let w3_example = nt_stringifier.serialize_graph(&graph)?.as_str();
+
+
+    let graph_data = graph.into_dataset();
+
+    let mut ld_jsonifier = JsonLdStringifier::new_stringifier();
+    let mut data_string = ld_jsonifier.serialize_dataset(&graph_data)?.to_string();
+
+    let test_obj: Value = serde_json::from_str(&data_string)?;
+
+    println!("The resulting JSON-LD from graph (parsed):\n{}\n", serde_json::to_string_pretty(&test_obj)?);
+
+
+
+    let mut test_graph = LightGraph::new();
+    policy.add_to_graph(&mut test_graph).expect("Wasn't able to add policy to graph.");
+
+    let mut nt2_stringifier = NtSerializer::new_stringifier();
+    let test_graph2 = nt2_stringifier.serialize_graph(&test_graph)?.as_str();
+    println!("\n\nThe resulting graph:\n{}", test_graph2);
+
+    let final_data = test_graph.into_dataset();
+
+    let mut new_jsonifier = JsonLdStringifier::new_stringifier();
+
+    let mut final_string = new_jsonifier.serialize_dataset(&final_data)?.to_string();
+
+    let final_obj: Value = serde_json::from_str(&final_string)?;
+
+    println!("The resulting JSON-LD from graph (parsed):\n{}\n", serde_json::to_string_pretty(&final_obj)?);
+
+    Ok::<(), Box<dyn std::error::Error>>(())
+}
+
+pub trait QuadsToString {
+    fn to_string(&self) -> String {
+        "Default".to_string()
+    }
+}
+
+impl<'a> QuadsToString for SimpleTerm<'a> {
+    fn to_string(&self) -> String {
+        match self {
+            SimpleTerm::Iri(iri) => iri.to_string(),
+            SimpleTerm::BlankNode(node) => node.to_string(),
+            SimpleTerm::LiteralDatatype(value, datatype) => format!("\"{}\"^^{}", value, datatype),
+            SimpleTerm::LiteralLanguage(value, language) => format!("\"{}\"@{}", value, language.to_string()),
+            _ => "Triple or Variable".to_string(), // TODO: Implement other types
+        }
+    }
+}

src/ODRL/Vocab/ActionTerm.rs

@@ -0,0 +1,298 @@
+use crate::ODRL::Vocabulary::Vocabulary;
+
+use std::collections::HashMap;
+use lazy_static::lazy_static;
+use std::sync::Mutex;
+
+
+#[derive(Clone)]
+struct ActionTerm {
+
+	value: String,
+	parent_term: Option<Box<ActionTerm>>,
+	child_terms: Vec<ActionTerm>,
+
+}
+
+impl ActionTerm {
+
+	pub fn new(value: String, parent_term: Option<Box<ActionTerm>>) -> Self {
+
+		let mut action_term = ActionTerm {
+			value,
+			parent_term: None,
+			child_terms: Vec::new(),
+		};
+
+		if let Some(mut parent) = parent_term {
+			parent.child_terms.push(action_term.clone());
+			action_term.parent_term = Some(parent);
+		}
+
+		action_term
+
+	}
+
+	pub fn get_ancestor_terms(&self) -> Vec<ActionTerm> {
+		let mut ancestors = Vec::new();
+		self.add_ancestor_term(&mut ancestors);
+		ancestors
+	}
+
+	fn add_ancestor_term(&self, ancestors: &mut Vec<ActionTerm>) {
+		if let Some(parent) = &self.parent_term {
+			ancestors.insert(0, (**parent).clone());
+			parent.add_ancestor_term(ancestors);
+		}
+	}
+
+	pub fn get_root_term(&self) -> ActionTerm {
+		let ancestors = self.get_ancestor_terms();
+		if !ancestors.is_empty() {
+			ancestors[0].clone()
+		} else {
+			self.clone()
+		}
+	}
+
+	pub fn get_descendant_terms(&self) -> Vec<ActionTerm> {
+		let mut descendants = Vec::new();
+		self.add_descendant_term(&mut descendants);
+		descendants
+	}
+
+	fn add_descendant_term(&self, descendants: &mut Vec<ActionTerm>) {
+		for child in &self.child_terms {
+			descendants.push(child.clone());
+			child.add_descendant_term(descendants);
+		}
+	}
+
+}
+
+lazy_static! {
+	static ref ACTIONTERMS: Mutex<HashMap<String, ActionTerm>> = {
+		let mut map = HashMap::new();
+		init_action_terms();
+		Mutex::new(map)
+	};
+}
+
+pub fn register_action_term(value: String, action_term: ActionTerm) {
+	ACTIONTERMS.lock().unwrap().insert(value, action_term);
+}
+
+fn init_action_terms() {
+
+	/// Actions for Permission or Prohibition
+
+	/// "use" and subitems
+	/* The Assigner permits/prohibits the Assignee to use the Asset as agreed.
+	More details may be defined in the applicable agreements or under applicable commercial laws.
+	Refined types of actions can be expressed by the narrower actions. */
+	let use_term = ActionTerm::new(Vocabulary::create_odrl_vocab_item("use"), None);
+	register_action_term("USE".to_string(), use_term.clone());
+
+	/* The Assigner permits/prohibits the Assignee(s) to use the Asset or parts of it as part of a composite collection. */
+	let aggregate_term = ActionTerm::new(Vocabulary::create_odrl_vocab_item("aggregate"), Some(Box::new(use_term.clone())));
+	register_action_term("AGGREGATE".to_string(), aggregate_term.clone());
+
+	/* 	The Assigner permits/prohibits the Assignee(s) to add explanatory notations/commentaries to the Asset without
+	modifying the Asset in any other way. */
+	let annotate_term = ActionTerm::new(Vocabulary::create_odrl_vocab_item("annotate"), Some(Box::new(use_term.clone())));
+	register_action_term("ANNOTATE".to_string(), annotate_term.clone());
+
+	/* The Assigner permits/prohibits the Assignee(s) to anonymize all or parts of the Asset.
+	For example, to remove identifying particulars for statistical or for other comparable purposes,
+	or to use the asset without stating the author / source */
+	let anonymize_term = ActionTerm::new(Vocabulary::create_odrl_vocab_item("anonymize"), Some(Box::new(use_term.clone())));
+	register_action_term("ANONYMIZE".to_string(), anonymize_term.clone());
+
+	/* The Assigner permits/prohibits the Assignee(s) to store the Asset (in a non-transient form).
+	Constraints may be used for temporal conditions. */
+	let archive_term = ActionTerm::new(Vocabulary::create_odrl_vocab_item("archive"), Some(Box::new(use_term.clone())));
+	register_action_term("ARCHIVE".to_string(), archive_term.clone());
+
+	/* 	The Assigner permits/prohibits the Assignee(s) to create multiple copies of the Asset that are being concurrently used. */
+	let concurrent_use_term = ActionTerm::new(Vocabulary::create_odrl_vocab_item("concurrent"), Some(Box::new(use_term.clone())));
+	register_action_term("CONCURRENT_USE".to_string(), concurrent_use_term.clone());
+
+	/* The Assigner permits/prohibits the Assignee(s) to create a new derivative Asset from this Asset and to edit or modify the derivative.
+	A new asset is created and may have significant overlaps with the original Asset. (Note that the notion of whether or not the change is
+	 significant enough to qualify as a new asset is subjective.) To the derived Asset a next policy may be applied. */
+	let derive_term = ActionTerm::new(Vocabulary::create_odrl_vocab_item("derive"), Some(Box::new(use_term.clone())));
+	register_action_term("DERIVE".to_string(), derive_term.clone());
+
+	/* The Assigner permits/prohibits the Assignee(s) to produce a digital copy of (or otherwise digitize) the Asset from its analogue form. */
+	let digitize_term = ActionTerm::new(Vocabulary::create_odrl_vocab_item("digitize"), Some(Box::new(use_term.clone())));
+	register_action_term("DIGITIZE".to_string(), digitize_term.clone());
+
+	/* The Assigner permits/prohibits the Assignee(s) to distribute the Asset. */
+	let distribute_term = ActionTerm::new(Vocabulary::create_odrl_vocab_item("distribute"), Some(Box::new(use_term.clone())));
+	register_action_term("DISTRIBUTE".to_string(), distribute_term.clone());
+
+	/* The Assigner permits/prohibits the Assignee(s) to run the computer program Asset.
+	For example, machine executable code or Java such as a game or application. */
+	let execute_term = ActionTerm::new(Vocabulary::create_odrl_vocab_item("execute"), Some(Box::new(use_term.clone())));
+	register_action_term("EXECUTE".to_string(), execute_term.clone());
+
+	/* The Assigner permits/prohibits the Assignee to grant the use the Asset to third parties.
+	This action enables the Assignee to create policies for the use of the Asset for third parties.
+	nextPolicy is recommended to be agreed with the third party. Use of temporal constraints is recommended. */
+	let grant_use_term = ActionTerm::new(Vocabulary::create_odrl_vocab_item("grantUse"), Some(Box::new(use_term.clone()))); // towards third-party only
+	register_action_term("GRANT_USE".to_string(), grant_use_term.clone());
+
+	/* The Assigner permits/prohibits the Assignee(s) to record the Asset in an index.
+	For example, to include a link to the Asset in a search engine database. */
+	let index_term = ActionTerm::new(Vocabulary::create_odrl_vocab_item("index"), Some(Box::new(use_term.clone())));
+	register_action_term("INDEX".to_string(), index_term.clone());
+
+	/* The Assigner permits/prohibits the Assignee(s) to load the computer program Asset onto a storage device
+	which allows operating or running the Asset. */
+	let install_term = ActionTerm::new(Vocabulary::create_odrl_vocab_item("install"), Some(Box::new(use_term.clone())));
+	register_action_term("INSTALL".to_string(), install_term.clone());
+
+	/* The Assigner permits/prohibits the Assignee(s) to update existing content of the Asset. A new asset is not created by this action.
+	This action will modify an asset which is typically updated from time to time without creating a new asset like a database.
+	If the result from modifying the asset should be a new asset the actions derive or extract should be used.
+	(Note that the notion of whether or not the change is significant enough to qualify as a new asset is subjective.) */
+	let modify_term = ActionTerm::new(Vocabulary::create_odrl_vocab_item("modify"), Some(Box::new(use_term.clone())));
+	register_action_term("MODIFY".to_string(), modify_term.clone());
+
+	/* The Assigner permits/prohibits the Assignee(s) to move the Asset from one digital location to another including deleting the original copy.
+	After the Asset has been moved, the original copy must be deleted. */
+	let move_term = ActionTerm::new(Vocabulary::create_odrl_vocab_item("move"), Some(Box::new(use_term.clone())));
+	register_action_term("MOVE".to_string(), move_term.clone());
+
+	/* The Assigner permits/prohibits the Assignee(s) to obtain data from the Asset.
+	For example, the ability to read a record from a database (the Asset). */
+	let read_term = ActionTerm::new(Vocabulary::create_odrl_vocab_item("read"), Some(Box::new(use_term.clone())));
+	register_action_term("READ".to_string(), read_term.clone());
+
+	/* The Assigner permits/prohibits the Assignee(s) to have a text Asset read out loud to an audience. */
+	let text_to_speech_term = ActionTerm::new(Vocabulary::create_odrl_vocab_item("textToSpeech"), Some(Box::new(use_term.clone())));
+	register_action_term("TEXT_TO_SPEECH".to_string(), text_to_speech_term.clone());
+
+	/* The Assigner permits/prohibits the Assignee(s) to make a digital copy of the digital Asset in another digital format.
+	Typically used to convert the Asset into a different format for consumption on/transfer to a third party system. */
+	let transform_term = ActionTerm::new(Vocabulary::create_odrl_vocab_item("transform"), Some(Box::new(use_term.clone())));
+	register_action_term("TRANSFORM".to_string(), transform_term.clone());
+
+	/* 	The Assigner permits/prohibits the Assignee(s) to translate the original natural language of an Asset into another natural language.
+	A new derivative Asset is created by that action. */
+	let translate_term = ActionTerm::new(Vocabulary::create_odrl_vocab_item("translate"), Some(Box::new(use_term.clone())));
+	register_action_term("TRANSLATE".to_string(), translate_term.clone());
+
+	/// "present" and subitems
+	/* The Assigner permits/prohibits the Assignee(s) to perform or exhibit an Asset to an audience. */
+	let present_term = ActionTerm::new(Vocabulary::create_odrl_vocab_item("present"), Some(Box::new(use_term.clone())));
+	register_action_term("PRESENT".to_string(), present_term.clone());
+
+	/* The Assigner permits/prohibits the Assignee(s) to display the visual media Asset to an audience or the public.
+	For example, displaying an image on a screen. */
+	let display_term = ActionTerm::new(Vocabulary::create_odrl_vocab_item("display"), Some(Box::new(present_term.clone())));
+	register_action_term("DISPLAY".to_string(), display_term.clone());
+
+	/* The Assigner permits/prohibits the Assignee(s) to perform an audio Asset to an audience. */
+	let play_term = ActionTerm::new(Vocabulary::create_odrl_vocab_item("play"), Some(Box::new(present_term.clone())));
+	register_action_term("PLAY".to_string(), play_term.clone());
+
+	/* The Assigner permits/prohibits the Assignee(s) to print an Asset onto paper or to create a hard copy.
+	For example, creating a permanent, fixed (static), and directly perceivable representation of the Asset. */
+	let print_term = ActionTerm::new(Vocabulary::create_odrl_vocab_item("print"), Some(Box::new(present_term.clone())));
+	register_action_term("PRINT".to_string(), print_term.clone());
+
+	/// "reproduce" and subitems
+	/* The Assigner permits/prohibits the Assignee(s) to make (an) exact reproduction(s) of the Asset. */
+	let reproduce_term = ActionTerm::new(Vocabulary::create_odrl_vocab_item("reproduce"), Some(Box::new(use_term.clone())));
+	register_action_term("REPRODUCE".to_string(), reproduce_term.clone());
+
+	/* The Assigner permits/prohibits the Assignee(s) to extract parts of the Asset and to use it as a new Asset.
+	A new asset is created and may have very little in common with the original Asset. (Note that the notion of
+	whether or not the change is significant enough to qualify as a new asset is subjective.) To the extracted
+	Asset a next policy may be applied. */
+	let extract_term = ActionTerm::new(Vocabulary::create_odrl_vocab_item("extract"), Some(Box::new(reproduce_term.clone())));
+	register_action_term("EXTRACT".to_string(), extract_term.clone());
+
+	/// "transfer" and subitems
+	/* The Assigner transfers/does not transfer the ownership in perpetuity to the Assignee(s). */
+	let transfer_term = ActionTerm::new(Vocabulary::create_odrl_vocab_item("transfer"), None);
+	register_action_term("TRANSFER".to_string(), transfer_term.clone());
+
+	/* The Assigner permits/prohibits the Assignee(s) to transfer the ownership of the Asset to a third party without
+	compensation and while deleting the original asset. */
+	let give_term = ActionTerm::new(Vocabulary::create_odrl_vocab_item("give"), Some(Box::new(transfer_term.clone()))); // towards third-party only
+	register_action_term("GIVE".to_string(), give_term.clone());
+
+	/* The Assigner permits/prohibits the Assignee(s) to transfer the ownership of the Asset to a third party with compensation and while deleting the original asset. */
+	let sell_term = ActionTerm::new(Vocabulary::create_odrl_vocab_item("sell"), Some(Box::new(transfer_term.clone()))); // towards third-party only
+	register_action_term("SELL".to_string(), sell_term.clone());
+
+
+	/// Actions for Duty
+	/* The Assigner requires that the Assignee(s) accepts that the use of the Asset may be tracked
+	The collected information may be tracked by the Assigner, or may link to a Party with the role function “trackingParty”. */
+	let accept_tracking_term = ActionTerm::new(Vocabulary::create_odrl_vocab_item("acceptTracking"), None);
+	register_action_term("ACCEPT_TRACKING".to_string(), accept_tracking_term.clone());
+
+	/* The Assigner requires that the Assignee(s) attributes the Asset to the Assigner or an attributed Party.
+	May link to an Asset with the attribution information. May link to a Party with the role function “attributedParty”. */
+	let attribute_term = ActionTerm::new(Vocabulary::create_odrl_vocab_item("attribute"), None);
+	register_action_term("ATTRIBUTE".to_string(), attribute_term.clone());
+
+	/* The Assigner requires that the Assignee(s) compensates the Assigner (or other specified compensation Party) by some amount of value,
+	if defined, for use of the Asset.
+	The compensation may use different types of things with a value:
+		– the  thing is expressed by the value (term) of the Constraint name
+		– the value is expressed by operator, rightOperand, dataType and unit */
+	let compensate_term = ActionTerm::new(Vocabulary::create_odrl_vocab_item("compensate"), None);
+	register_action_term("COMPENSATE".to_string(), compensate_term.clone());
+
+	/* The Assigner requires that the Assignee(s) permanently removes all copies of the Asset.
+	Use a constraint to define under which conditions the Asset should be deleted. */
+	let delete_term = ActionTerm::new(Vocabulary::create_odrl_vocab_item("delete"), None);
+	register_action_term("DELETE".to_string(), delete_term.clone());
+
+	/* The Assignee requires that the Assigner(s) ensure(s) that the permission on the Asset is exclusive to the Assignee. */
+	let ensure_exclusivity_term = ActionTerm::new(Vocabulary::create_odrl_vocab_item("ensureExclusivity"), None);
+	register_action_term("ENSURE_EXCLUSIVITY".to_string(), ensure_exclusivity_term.clone());
+
+	/* The Assigner requires that the Assignee(s) include(s) other related assets in the Asset.
+	For example; Bio picture must be included in the attribution. Use of the Asset relation attribute is required */
+	let include_term = ActionTerm::new(Vocabulary::create_odrl_vocab_item("include"), None);
+	register_action_term("INCLUDE".to_string(), include_term.clone());
+
+	/* The Assigner requires that the Assignee(s) inform(s) the Assigner or an informed Party that an action has been performed
+	in relation to the Asset.
+	May link to a Party with the role function “informedParty”. */
+	let inform_term = ActionTerm::new(Vocabulary::create_odrl_vocab_item("inform"), None);
+	register_action_term("INFORM".to_string(), inform_term.clone());
+
+	/* The Assigner requires that the Assignee(s) grants the specified Policy to a third party for their use of the Asset. */
+	let next_policy_term = ActionTerm::new(Vocabulary::create_odrl_vocab_item("nextPolicy"), None);
+	register_action_term("NEXT_POLICY".to_string(), next_policy_term.clone());
+
+	/* The Assigner requires that the Assignee(s) obtains explicit consent from the Assigner or a consenting Party to perform the requested
+	action in relation to the Asset.
+	Used as a Duty to ensure that the Assigner or a Party is authorized to approve such actions on a case-by-case basis.
+	May link to a Party with the role function “consentingParty”. */
+	let obtain_consent_term = ActionTerm::new(Vocabulary::create_odrl_vocab_item("obtainConsent"), None);
+	register_action_term("OBTAIN_CONSENT".to_string(), obtain_consent_term.clone());
+
+	/* The Assigner requires that the Assignee(s) has(ve) a person review the Policy applicable to the Asset.
+	Used when human intervention is required to review the Policy. May link to an Asset which represents the full Policy information. */
+	let review_policy_term = ActionTerm::new(Vocabulary::create_odrl_vocab_item("reviewPolicy"), None);
+	register_action_term("REVIEW_POLICY".to_string(), review_policy_term.clone());
+
+	/* The Assigner requires that the Assignee(s) unload(s) and delete(s) the computer program Asset from a storage device and
+	disable(s) its readiness for operation.
+	The Asset is no longer accessible to the Assignee(s). */
+	let uninstall_term = ActionTerm::new(Vocabulary::create_odrl_vocab_item("uninstall"), None);
+	register_action_term("UNINSTALL".to_string(), uninstall_term.clone());
+
+	/* The Assigner requires that the Assignee(s) apply(ies) a watermark as provided by the Assigner to the Asset.
+	It is recommended to embed a link to the watermark. */
+	let watermark_term = ActionTerm::new(Vocabulary::create_odrl_vocab_item("watermark"), None);
+	register_action_term("WATERMARK".to_string(), watermark_term.clone());
+
+}

src/ODRL/Vocab/AssetRelationTerm.rs

@@ -0,0 +1,60 @@
+use crate::ODRL::Vocabulary::Vocabulary;
+use crate::datatypes::URI::URI;
+
+use std::collections::HashMap;
+use lazy_static::lazy_static;
+use std::sync::Mutex;
+
+pub struct AssetRelationTerm {
+
+	value: String,
+
+}
+
+impl AssetRelationTerm {
+
+	fn new(value: String) -> Self {
+		AssetRelationTerm {
+			value: value.to_string(),
+		}
+	}
+
+	fn new_from_uri(uri: URI) -> Self {
+		AssetRelationTerm::new(uri.value)
+	}
+
+}
+
+lazy_static! {
+	static ref ASSETRELATIONTERMS: Mutex<HashMap<String, AssetRelationTerm>> = {
+		let mut map = HashMap::new();
+		init_asset_relation_terms();
+		Mutex::new(map)
+	};
+}
+
+pub fn register_asset_relation_term(value: String, assetrelationterm: AssetRelationTerm) {
+	ASSETRELATIONTERMS.lock().unwrap().insert(value, assetrelationterm);
+}
+
+/// Terms for the attribute “relation” of the entity Relation
+fn init_asset_relation_terms() {
+
+	/* 	The Asset upon which the Action is performed
+	This is the default value and must be supported. Only one target can be specified. */
+	register_asset_relation_term("TARGET".to_string(), AssetRelationTerm::new(Vocabulary::create_odrl_vocab_item("target")));
+
+	/* The Asset which is created from the output of the Action
+	For example, can indicate that a Translated Asset uses a specific UID.
+	This UID of the newly created Asset can then be used in other Policy expressions. */
+	register_asset_relation_term("OUTPUT".to_string(), AssetRelationTerm::new(Vocabulary::create_odrl_vocab_item("output")));
+
+}
+
+pub fn is_asset_relation_term(value: String) -> bool {
+	ASSETRELATIONTERMS.lock().unwrap().contains_key(&value)
+}
+
+pub fn get_asset_relation_term_values() -> Vec<String> {
+	ASSETRELATIONTERMS.lock().unwrap().keys().map(|key| key.to_string()).collect()
+}

src/ODRL/Vocab/ConstraintOperator.rs

@@ -0,0 +1,87 @@
+use crate::ODRL::Vocabulary::Vocabulary;
+use crate::datatypes::URI::URI;
+
+use std::collections::HashMap;
+use lazy_static::lazy_static;
+use std::sync::Mutex;
+
+pub struct ConstraintOperator {
+
+	value: String,
+
+}
+
+impl ConstraintOperator {
+
+	fn new(value: String) -> Self {
+		ConstraintOperator {
+			value: value.to_string(),
+		}
+	}
+
+	fn new_from_uri(uri: URI) -> Self {
+		ConstraintOperator::new(uri.value)
+	}
+
+}
+
+lazy_static! {
+	static ref CONSTRAINTOPERATORS: Mutex<HashMap<String, ConstraintOperator>> = {
+		let mut map = HashMap::new();
+		init_constraint_operators();
+		Mutex::new(map)
+	};
+}
+
+pub fn register_constraint_operator(value: String, constraintoperator: ConstraintOperator) {
+	CONSTRAINTOPERATORS.lock().unwrap().insert(value, constraintoperator);
+}
+
+/// Terms for the attribute “operator” of the entity Constraint
+fn init_constraint_operators() {
+
+	/* 	The “Equals” operator indicating that a given value equals the rightOperand of the Constraint */
+	register_constraint_operator("EQUAL".to_string(), ConstraintOperator::new(Vocabulary::create_odrl_vocab_item("eq")));
+
+	/* The “Greater Than” operator indicating that a given value is greater than the rightOperand of the Constraint */
+	register_constraint_operator("GREATER_THAN".to_string(), ConstraintOperator::new(Vocabulary::create_odrl_vocab_item("gt")));
+
+	/* The “Greater Than or Equal To” operator indicating that a given value is greater than or equal to the rightOperand of the Constraint */
+	register_constraint_operator("GREATER_THAN_OR_EQUAL".to_string(), ConstraintOperator::new(Vocabulary::create_odrl_vocab_item("gteq")));
+
+	/* The “Has Part” operator indicating that a given value contains the rightOperand of the Constraint */
+	register_constraint_operator("HAS_PART".to_string(), ConstraintOperator::new(Vocabulary::create_odrl_vocab_item("hasPart")));
+
+	/* The “Is A” operator indicating that a given value is an instance of the rightOperand of the Constraint */
+	register_constraint_operator("IS_A".to_string(), ConstraintOperator::new(Vocabulary::create_odrl_vocab_item("isA")));
+
+	/* The “Is All Of” operator indicating that a given value is all of the rightOperand of the Constraint */
+	register_constraint_operator("IS_ALL_OF".to_string(), ConstraintOperator::new(Vocabulary::create_odrl_vocab_item("isAllOf")));
+
+	/* The “Is Any Of” operator indicating that a given value is any of the rightOperand of the Constraint */
+	register_constraint_operator("IS_ANY_OF".to_string(), ConstraintOperator::new(Vocabulary::create_odrl_vocab_item("isAnyOf")));
+
+	/* The “Is None Of” operator indicating that a given value is none of the rightOperand of the Constraint */
+	register_constraint_operator("IS_NONE_OF".to_string(), ConstraintOperator::new(Vocabulary::create_odrl_vocab_item("isNoneOf")));
+
+	/* The “Is Part Of” operator indicating that a given value is part of the rightOperand of the Constraint */
+	register_constraint_operator("IS_PART_OF".to_string(), ConstraintOperator::new(Vocabulary::create_odrl_vocab_item("isPartOf")));
+
+	/* The “Less Than” operator indicating that a given value is less than the rightOperand of the Constraint */
+	register_constraint_operator("LESS_THAN".to_string(), ConstraintOperator::new(Vocabulary::create_odrl_vocab_item("lt")));
+
+	/* The “Less Than or Equal To” operator indicating that a given value is less than or equal to the rightOperand of the Constraint */
+	register_constraint_operator("LESS_THAN_OR_EQUAL".to_string(), ConstraintOperator::new(Vocabulary::create_odrl_vocab_item("lteq")));
+
+	/* The “Not Equal To” operator indicating that a given value is not equal to the rightOperand of the Constraint */
+	register_constraint_operator("NOT_EQUAL".to_string(), ConstraintOperator::new(Vocabulary::create_odrl_vocab_item("neq")));
+
+}
+
+pub fn is_constraint_operator(value: String) -> bool {
+	CONSTRAINTOPERATORS.lock().unwrap().contains_key(&value)
+}
+
+pub fn get_constraint_operator_values() -> Vec<String> {
+	CONSTRAINTOPERATORS.lock().unwrap().keys().map(|x| x.to_string()).collect()
+}

src/ODRL/Vocab/ConstraintTerm.rs

@@ -0,0 +1,155 @@
+use crate::ODRL::Vocabulary::Vocabulary;
+use crate::datatypes::URI::URI;
+
+use std::collections::HashMap;
+use lazy_static::lazy_static;
+use std::sync::Mutex;
+
+pub struct ConstraintTerm {
+
+	value: String,
+
+}
+
+impl ConstraintTerm {
+
+	fn new(value: String) -> Self {
+		ConstraintTerm {
+			value: value.to_string(),
+		}
+	}
+
+	fn new_from_uri(uri: URI) -> Self {
+		ConstraintTerm::new(uri.value)
+	}
+
+}
+
+lazy_static! {
+	static ref CONSTRAINTTERMS: Mutex<HashMap<String, ConstraintTerm>> = {
+		let mut map = HashMap::new();
+		init_constraint_terms();
+		Mutex::new(map)
+	};
+}
+
+pub fn register_constraint_term(value: String, constraintterm: ConstraintTerm) {
+	CONSTRAINTTERMS.lock().unwrap().insert(value, constraintterm);
+}
+
+/// Terms for the attribute “name” of the entity Constraint
+fn init_constraint_terms() {
+
+	/* A point defined with absolute coordinates
+	For example, JPEG image must be positioned at 100×100 pixel location. This may be used to express [PLUS] semantics. */
+	register_constraint_term("ABSOLUTE_POSITION".to_string(), ConstraintTerm::new(Vocabulary::create_odrl_vocab_item("absolutePosition")));
+
+	/* The absolute dimension that the Asset may be resized
+	For example, JPEG image must be reproduced onto an area no larger than A0. This may be used to express [PLUS] semantics. */
+	register_constraint_term("ABSOLUTE_SIZE".to_string(), ConstraintTerm::new(Vocabulary::create_odrl_vocab_item("absoluteSize")));
+
+	/* 	The numeric count indicating the number of times the corresponding entity may be exercised
+	Should be a positive integer. */
+	register_constraint_term("COUNT".to_string(), ConstraintTerm::new(Vocabulary::create_odrl_vocab_item("count")));
+
+	/* The date (and optional time and timezone) representing a point in time or period
+	Date and Time value must conform to [ISO-8601] as represented in [W3CXMLSCHEMA]. The use of Timezone information is strongly recommended. */
+	register_constraint_term("DATE_TIME".to_string(), ConstraintTerm::new(Vocabulary::create_odrl_vocab_item("dateTime")));
+
+	/* The file format applicable to the Asset
+	For example, this may be used to express [PLUS] semantics; only JPEG image may be distributed. */
+	register_constraint_term("FILE_FORMAT".to_string(), ConstraintTerm::new(Vocabulary::create_odrl_vocab_item("fileFormat")));
+
+	/* The defined industry sector applicable to the asset usage
+	For example, publishing, financial. */
+	register_constraint_term("INDUSTRY".to_string(), ConstraintTerm::new(Vocabulary::create_odrl_vocab_item("industry")));
+
+	/* The natural language applicable to the asset usage
+	For example, this may be used to express [PLUS] semantics; JPEG image may only be reproduced with Spanish text. Must use [BCP-47] codes. */
+	register_constraint_term("LANGUAGE".to_string(), ConstraintTerm::new(Vocabulary::create_odrl_vocab_item("language")));
+
+	/* The delivery channel used for storing or communicating the asset
+	For example, the asset may be distributed only on mobile networks. */
+	register_constraint_term("DELIVERY_CHANNEL".to_string(), ConstraintTerm::new(Vocabulary::create_odrl_vocab_item("deliveryChannel")));
+
+	/* A period of time in which the policy action can be exercised.
+	The start of the period is when the action is first exercised. */
+	register_constraint_term("ELAPSED_TIME".to_string(), ConstraintTerm::new(Vocabulary::create_odrl_vocab_item("elapsedTime")));
+
+	/* 	Specification of a defined event applicable to the asset usage
+	For example, asset may be used at the “FIFA World Cup” only. To express events related to undertaking Duties, a specific event value has been defined:
+		policyUsage – the time period whilst the policy is being exercised
+	This will enable constraints to be expressed such as “event lt o:policyUsage” indicating before the policy is exercised. */
+	register_constraint_term("EVENT".to_string(), ConstraintTerm::new(Vocabulary::create_odrl_vocab_item("event")));
+
+	/* The media type in which the asset may be used
+	For example, electronic, print, advertising, marketing. This may be used to express [PLUS] semantics. */
+	register_constraint_term("MEDIA".to_string(), ConstraintTerm::new(Vocabulary::create_odrl_vocab_item("media")));
+
+	/* The maximum period of metered usage time
+	Value must conform to [ISO-8601] as represented in [W3CXMLSCHEMA]. For example “P30H” indicates a 30 hour period. */
+	register_constraint_term("METERED_TIME".to_string(), ConstraintTerm::new(Vocabulary::create_odrl_vocab_item("meteredTime")));
+
+	/* The value of the financial payment
+	The dataType attribute may be used to indicate the type of the value (eg decimal) and the unit attribute to indicate the currency.
+	May be used for compensation duties. */
+	register_constraint_term("PAY_AMOUNT".to_string(), ConstraintTerm::new(Vocabulary::create_odrl_vocab_item("payAmount")));
+
+	/* The amount (as a percentage) of the action applicable to the asset
+	A numeric value from 0 to 100. For example, extract a maximum of 50% of the asset */
+	register_constraint_term("PERCENTAGE".to_string(), ConstraintTerm::new(Vocabulary::create_odrl_vocab_item("percentage")));
+
+	/* The specified Product or Service name
+	For example, this may be used to express [PLUS] semantics; images may only be reproduced in the XYZ Magazine. */
+	register_constraint_term("PRODUCT".to_string(), ConstraintTerm::new(Vocabulary::create_odrl_vocab_item("product")));
+
+	/* Specification of a defined purpose applicable to the asset usage
+	For example, educational use. [P3P] Purpose values may also be used. */
+	register_constraint_term("PURPOSE".to_string(), ConstraintTerm::new(Vocabulary::create_odrl_vocab_item("purpose")));
+
+	/* The party that receives the result of the Action on the Asset
+	The right operand must identify one or more specific parties or categories of party */
+	register_constraint_term("RECIPIENT".to_string(), ConstraintTerm::new(Vocabulary::create_odrl_vocab_item("recipient")));
+
+	/* 	A point defined with reference to another position
+	For example, this may be used to express [PLUS] semantics; JPEG image must be positioned at the Top of the Page. */
+	register_constraint_term("RELATIVE_POSITION".to_string(), ConstraintTerm::new(Vocabulary::create_odrl_vocab_item("relativePosition")));
+
+	/* The relative dimension that the Asset may be resized
+	For example, this may be used to express [PLUS] semantics; JPEG image resized to maximum of 200%. */
+	register_constraint_term("RELATIVE_SIZE".to_string(), ConstraintTerm::new(Vocabulary::create_odrl_vocab_item("relativeSize")));
+
+	/* The resolution at which the asset may be used
+	For example, may be printed at 1200dpi. */
+	register_constraint_term("RESOLUTION".to_string(), ConstraintTerm::new(Vocabulary::create_odrl_vocab_item("resolution")));
+
+	/* A code representing a geospatial area
+	The code value and code source must be represented.
+	For example, the ISO-3166 Country Codes and the Getty Thesaurus of Geographic Names. A URI should be used to represent this value. */
+	register_constraint_term("SPATIAL".to_string(), ConstraintTerm::new(Vocabulary::create_odrl_vocab_item("spatial")));
+
+	/* Recurring period of time in which the usage may be exercised
+	Interval value must conform to [ISO-8601] as represented in [W3CXMLSCHEMA]. For example, “P7D” indicates a 7 day period. */
+	register_constraint_term("TIME_INTERVAL".to_string(), ConstraintTerm::new(Vocabulary::create_odrl_vocab_item("timeInterval")));
+
+	/* An identifiable computing system
+	For example, identifiable via the CPU or unique hardware address. */
+	register_constraint_term("SYSTEM_DEVICE".to_string(), ConstraintTerm::new(Vocabulary::create_odrl_vocab_item("systemDevice")));
+
+	/* The scope of versions for the asset
+	For example, Single Paperback, or Multiple Issues. This may be used to express [PLUS] semantics. */
+	register_constraint_term("VERSION".to_string(), ConstraintTerm::new(Vocabulary::create_odrl_vocab_item("version")));
+
+	/* Specification of a digital locale
+	For example, an Internet domain or IP address range */
+	register_constraint_term("VIRTUAL_LOCATION".to_string(), ConstraintTerm::new(Vocabulary::create_odrl_vocab_item("virtualLocation")));
+
+}
+
+pub fn is_constraint_term(value: String) -> bool {
+	CONSTRAINTTERMS.lock().unwrap().contains_key(&value)
+}
+
+pub fn get_constraint_terms_values() -> Vec<String> {
+	CONSTRAINTTERMS.lock().unwrap().keys().map(|x| x.to_string()).collect()
+}

src/ODRL/Vocab/FunctionTerm.rs

@@ -0,0 +1,79 @@
+use crate::ODRL::Vocabulary::Vocabulary;
+use crate::datatypes::URI::URI;
+
+use std::collections::HashMap;
+use lazy_static::lazy_static;
+use std::sync::Mutex;
+
+pub struct FunctionTerm {
+
+	value: String,
+
+}
+
+impl FunctionTerm {
+
+	fn new(value: String) -> Self {
+		FunctionTerm {
+			value: value.to_string(),
+		}
+	}
+
+	fn new_from_uri(uri: URI) -> Self {
+		FunctionTerm::new(uri.value)
+	}
+
+}
+
+lazy_static! {
+	static ref FUNCTIONTERMS: Mutex<HashMap<String, FunctionTerm>> = {
+		let mut map = HashMap::new();
+		init_function_terms();
+		Mutex::new(map)
+	};
+}
+
+pub fn register_function_term(value: String, functionterm: FunctionTerm) {
+	FUNCTIONTERMS.lock().unwrap().insert(value, functionterm);
+}
+
+/// Terms for the attribute “function” of the entity Role
+fn init_function_terms() {
+
+	/* The Party is the issuer of the policy statement
+	Must be supported. */
+	register_function_term("ASSIGNER".to_string(), FunctionTerm::new(Vocabulary::create_odrl_vocab_item("assigner")));
+
+	/* The Party is the recipient of the policy statement
+	Must be supported. */
+	register_function_term("ASSIGNEE".to_string(), FunctionTerm::new(Vocabulary::create_odrl_vocab_item("assignee")));
+
+	/* The Party to be attributed
+	May be specified as part of the attribute action. */
+	register_function_term("ATTRIBUTED_PARTY".to_string(), FunctionTerm::new(Vocabulary::create_odrl_vocab_item("attributedParty")));
+
+	/* The Party to obtain consent from
+	May be specified as part of the obtainConsent action. */
+	register_function_term("CONSENTING_PARTY".to_string(), FunctionTerm::new(Vocabulary::create_odrl_vocab_item("consentingParty")));
+
+	/* The Party to be informed of all uses
+	May be specified as part of the inform action. */
+	register_function_term("INFORMED_PARTY".to_string(), FunctionTerm::new(Vocabulary::create_odrl_vocab_item("informedParty")));
+
+	/* The Party is the recipient of the compensation
+	May be specified as part of the compensate duty action. */
+	register_function_term("COMPENSATED_PARTY".to_string(), FunctionTerm::new(Vocabulary::create_odrl_vocab_item("compensatedParty")));
+
+	/* 	The Party is the usage tracker
+	May be specified as part of the acceptTracking action. */
+	register_function_term("TRACKING_PARTY".to_string(), FunctionTerm::new(Vocabulary::create_odrl_vocab_item("trackingParty")));
+
+}
+
+pub fn is_function_term(term: &str) -> bool {
+	FUNCTIONTERMS.lock().unwrap().contains_key(term)
+}
+
+pub fn get_function_term_values() -> Vec<String> {
+	FUNCTIONTERMS.lock().unwrap().keys().map(|term| term.to_string()).collect()
+}

src/ODRL/Vocab/PolicyType.rs

@@ -0,0 +1,85 @@
+use crate::ODRL::Vocabulary::Vocabulary;
+use crate::datatypes::URI::URI;
+
+use std::collections::HashMap;
+use lazy_static::lazy_static;
+use std::sync::Mutex;
+
+pub struct PolicyType {
+
+	value: String,
+
+}
+
+impl PolicyType {
+
+	pub fn new(value: String) -> Self {
+		PolicyType {
+			value: value.to_string(),
+		}
+	}
+
+	pub fn new_policy_type_from_uri(uri: URI) -> Self {
+		PolicyType::new(uri.value)
+	}
+
+}
+
+lazy_static! {
+	static ref POLICIES: Mutex<HashMap<String, PolicyType>> = {
+		let mut map = HashMap::new();
+		init_policies();
+		Mutex::new(map)
+	};
+}
+
+pub fn register_policy_type(value: String, policy_type: PolicyType) {
+	POLICIES.lock().unwrap().insert(value, policy_type);
+}
+
+fn init_policies() {
+
+	/// Policy expressions that consists of entities from the complete model
+	/// The Set is aimed at scenarios where there is an open criteria for the semantics of the
+	/// policy expressions and typically refined by other systems/profiles that process the
+	/// information at a later time. No privileges are granted to any Party.
+	register_policy_type("SET".to_string(), PolicyType::new(Vocabulary::create_odrl_vocab_item("set")));
+
+	/// Policy expressions that propose terms of usage from an Asset owner
+	/// Must contain a Party entity with Assigner role. The Offer may contain a Party entity
+	/// with Assignee role, but does not grant any privileges to that Party.
+	register_policy_type("OFFER".to_string(), PolicyType::new(Vocabulary::create_odrl_vocab_item("offer")));
+
+	/// Policy expressions that are formal contracts (or licenses) stipulating all the terms of usage and all the parties involved.
+	/// Must contain at least the Party entity with Assigner role and a Party with Assignee role.
+	/// The latter being granted the terms of the Agreement from the former.
+	register_policy_type("AGREEMENT".to_string(), PolicyType::new(Vocabulary::create_odrl_vocab_item("agreement")));
+
+	/// Policy expressions that propose terms of usage to an Asset owner
+	/// Must contain a Party entity with Assignee role. The Request may also contain the Party
+	/// entity with Assigner role if this is known. No privileges are granted to any Party.
+	register_policy_type("REQUEST".to_string(), PolicyType::new(Vocabulary::create_odrl_vocab_item("request")));
+
+	/// Policy expressions that stipulate the terms of usage over personal information.
+	/// Must contain at least the Party entity with Assigner role and a Party with Assignee role.
+	/// Must also contain a Duty on the assignee related to obligations towards managing the
+	/// assigner’s Asset containing personal information. The Assignee is being granted the terms
+	/// of the Privacy policy from the Assigner.
+	register_policy_type("PRIVACY".to_string(), PolicyType::new(Vocabulary::create_odrl_vocab_item("privacy")));
+
+	/// Policy expressions that stipulate the terms of usage and is redeemable by any Party who currently holds the Ticket in their possession
+	/// May contain the Party entity with Assigner role and the Party entity with Assignee role.
+	/// A Ticket (or Voucher) may be anonymous or personalised, where the holder of that
+	/// Ticket may remain unknown or has to be identified. The holder, or if known, the Assignee,
+	/// is being granted the terms of the Ticket from the Assigner (in known).
+	register_policy_type("TICKET".to_string(), PolicyType::new(Vocabulary::create_odrl_vocab_item("ticket")));
+
+}
+
+pub fn is_policy_type(uri: &URI) -> bool {
+	POLICIES.lock().unwrap().contains_key(&uri.value)
+}
+
+pub fn get_policies_values() -> Vec<String> {
+	POLICIES.lock().unwrap().keys().map(|k| k.to_string()).collect()
+}

src/ODRL/Vocab/ScopeTerm.rs

@@ -0,0 +1,74 @@
+use crate::ODRL::Vocabulary::Vocabulary;
+use crate::datatypes::URI::URI;
+
+use std::collections::HashMap;
+use lazy_static::lazy_static;
+use std::sync::Mutex;
+
+pub struct ScopeTerm {
+
+	value: String,
+
+}
+
+impl ScopeTerm {
+
+	fn new(value: String) -> Self {
+		ScopeTerm {
+			value: value.to_string(),
+		}
+	}
+
+	fn new_from_uri(uri: URI) -> Self {
+		ScopeTerm::new(uri.value)
+	}
+
+}
+
+lazy_static! {
+	static ref SCOPETERMS: Mutex<HashMap<String, ScopeTerm>> = {
+		let mut map = HashMap::new();
+		init_scope_terms();
+		Mutex::new(map)
+	};
+}
+
+pub fn register_scope_term(value: String, scopeterm: ScopeTerm) {
+	SCOPETERMS.lock().unwrap().insert(value, scopeterm);
+}
+
+/// Terms for the attribute “scope” of the entity Role
+fn init_scope_terms() {
+
+	/* The Party is a single individual
+	Must be supported. */
+	register_scope_term("INDIVIDUAL".to_string(), ScopeTerm::new(Vocabulary::create_odrl_vocab_item("Individual")));
+
+	/* The Party represents a defined group with multiple individual members
+	Must be supported. */
+	register_scope_term("GROUP".to_string(), ScopeTerm::new(Vocabulary::create_odrl_vocab_item("Group")));
+
+	/* All the collective individuals within a context
+	For example, may be used to indicate all the users of a specific social network the party is a member of. Note that “group” scope is also assumed. */
+	register_scope_term("ALL".to_string(), ScopeTerm::new(Vocabulary::create_odrl_vocab_item("All")));
+
+	/* All the first-level connections of the Party
+	For example, may be used to indicate all “friends” of the Party. Note that “group” scope is also assumed. */
+	register_scope_term("ALL_CONNECTIONS".to_string(), ScopeTerm::new(Vocabulary::create_odrl_vocab_item("AllConnections")));
+
+	/* All the second-level connections of the Party
+	For example, may be used to indicate all “friends of friends” of the Party. Note that “group” scope is also assumed. */
+	register_scope_term("ALL_2ND_CONNECTIONS".to_string(), ScopeTerm::new(Vocabulary::create_odrl_vocab_item("All2ndConnections")));
+
+	/* 	All the group connections of the Party
+	For example, may be used to indicate all groups that the Party is a member of. Note that “group” scope is also assumed. */
+	register_scope_term("ALL_GROUPS".to_string(), ScopeTerm::new(Vocabulary::create_odrl_vocab_item("AllGroups")));
+}
+
+pub fn is_scope_term(value: String) -> bool {
+	SCOPETERMS.lock().unwrap().contains_key(&value)
+}
+
+pub fn get_scope_term_values() -> Vec<String> {
+	SCOPETERMS.lock().unwrap().keys().map(|key| key.to_string()).collect()
+}

src/ODRL/Vocab/mod.rs

@@ -0,0 +1,7 @@
+pub mod ActionTerm;
+pub mod AssetRelationTerm;
+pub mod ConstraintOperator;
+pub mod ConstraintTerm;
+pub mod FunctionTerm;
+pub mod PolicyType;
+pub mod ScopeTerm;

src/ODRL/Vocabulary.rs

@@ -0,0 +1,32 @@
+use crate::datatypes::URI::URI;
+
+pub struct Vocabulary;
+
+impl Vocabulary {
+
+	fn new() -> Self {
+		Vocabulary
+	}
+
+	const ODRL_NS: &'static str = "http://www.w3.org/ns/odrl/2/";
+
+	pub fn create_vocab_identifier(namespace_uri: &str, name: &str) -> String {
+		format!("{}{}", namespace_uri, name)
+	}
+
+	/// The URI identifying the ODRL Version 2 Common Vocabulary is defined as:
+	///
+	///    http://www.w3.org/ns/odrl/2/
+	///
+	/// This URI must be used in all encodings of ODRL policies to refer to the ODRL Common Vocabulary.
+	/// A URI identifying an ODRL Common Vocabulary term is created by appending the identifier of that term to the URI of the vocabulary.
+	///
+	/// For example, below are the target and play terms:
+	///
+	///    http://www.w3.org/ns/odrl/2/target
+	///    http://www.w3.org/ns/odrl/2/play
+	pub fn create_odrl_vocab_item(name: &str) -> String {
+		Self::create_vocab_identifier(Self::ODRL_NS, name)
+	}
+
+}

src/ODRL/mod.rs

@@ -0,0 +1,4 @@
+pub mod JsonParser;
+pub mod Serializer;
+mod Vocabulary;
+mod Vocab;

src/datatypes/URI.rs

@@ -0,0 +1,80 @@
+use uuid::Uuid;
+use url::Url;
+
+use std::cmp::PartialEq;
+use std::str::FromStr;
+
+#[derive(Eq)]
+pub struct URI {
+	pub value: String,
+	pub is_uri: bool,
+}
+
+impl URI {
+	fn new(value: Option<String>) -> Self {
+
+		let mut uri = URI {
+			value: String::new(),
+			is_uri: false,
+		};
+
+		if let Some(v) = value {
+			uri.value = v;
+		}
+
+		uri
+	}
+
+	fn generate_random() -> Self {
+		URI::new(Some(Uuid::new_v4().to_string()))
+	}
+
+	fn check_uri(&mut self) {
+		if let Ok(_) = Url::parse(&self.value) {
+			self.is_uri = true;
+		}
+	}
+
+	pub fn to_string(&self) -> &str {
+		&self.value
+	}
+
+	pub fn to_uri(&self) -> Result<Url, DataTypeException> {
+		Url::parse(&self.value).map_err(|_| DataTypeException::new("Value is not a valid URI"))
+	}
+
+}
+
+impl PartialEq for URI {
+	fn eq(&self, other: &Self) -> bool {
+		self.value == other.value
+	}
+}
+
+#[derive(Debug)]
+pub struct DataTypeException {
+	message: String,
+}
+
+impl DataTypeException {
+	fn new(message: &str) -> Self {
+		DataTypeException {
+			message: message.to_string(),
+		}
+	}
+}
+
+impl FromStr for URI {
+	type Err = DataTypeException;
+
+	fn from_str(s: &str) -> Result<Self, Self::Err> {
+		let mut uri = URI::new(None);
+		uri.value = s.to_string();
+		uri.check_uri();
+
+		if !uri.is_uri {
+			return Err(DataTypeException::new("Invalid value. Value format must conform to a URI"));
+		}
+		Ok(uri)
+	}
+}

src/datatypes/mod.rs

@@ -0,0 +1 @@
+pub mod URI;

src/main.rs

@@ -0,0 +1,46 @@
+pub mod NameSpaces;
+
+mod model {
+
+    pub mod Action;
+    pub mod Asset;
+    pub mod ConflictTerm;
+    pub mod Constraint;
+    pub mod Party;
+    pub mod Policy;
+    pub mod Rule;
+    pub mod TypeAlias;
+
+}
+
+mod datatypes {
+
+    pub mod URI;
+
+}
+
+mod ODRL {
+
+    pub mod JsonParser;
+    pub mod Serializer;
+    pub mod Vocabulary;
+    pub mod Vocab {
+        pub mod ActionTerm;
+        pub mod AssetRelationTerm;
+        pub mod ConstraintOperator;
+        pub mod ConstraintTerm;
+        pub mod FunctionTerm;
+        pub mod PolicyType;
+        pub mod ScopeTerm;
+    }
+
+}
+
+use ODRL::Serializer as ODRLSerializer;
+
+fn main() {
+
+    ODRLSerializer::main();
+
+
+}

src/model/Action.rs

@@ -0,0 +1,45 @@
+use crate::model::Constraint::Constraint;
+
+#[derive(Debug, Clone)]
+pub struct Action {
+
+    pub name: String,
+    pub refinements: Vec<Constraint>,
+    pub included_in: Option<Box<Action>>, // Use Box to allow recursive type definition
+    pub implies: Vec<Box<Action>>,
+
+}
+
+impl Action {
+
+    pub fn new(name: &str, refinements: Vec<Constraint>, included_in: Option<Action>, implies: Vec<Action>) -> Action {
+        Action {
+            name: name.to_string(),
+            refinements,
+            included_in: match included_in {
+                Some(action) => Some(Box::new(action)),
+                None => None,
+            },
+            implies: implies.into_iter().map(Box::new).collect(),
+        }
+    }
+
+    // Function to create the two top level actions "use" and "transfer"
+    pub fn init_top_level() -> (Action, Action) {
+        let use_action = Action {
+            name: "use".to_string(),
+            refinements: vec![],
+            included_in: None,
+            implies: vec![],
+        };
+        let transfer_action = Action {
+            name: "transfer".to_string(),
+            refinements: vec![],
+            included_in: None,
+            implies: vec![],
+        };
+
+        (use_action, transfer_action)
+    }
+
+}

src/model/Asset.rs

@@ -0,0 +1,66 @@
+use crate::model::Policy::Policy;
+use crate::model::Constraint::Constraint;
+use crate::model::TypeAlias::IRI;
+
+
+#[derive(Debug, Clone)]
+pub struct Relation {
+
+    pub target: Option<Box<Asset>>,
+
+}
+
+impl Relation {
+
+    pub fn new(target: Option<Asset>) -> Relation {
+        Relation {
+            target: match target {
+                Some(asset) => Some(Box::new(asset)),
+                None => None,
+            }
+        }
+    }
+
+}
+
+#[derive(Debug, Clone)]
+pub struct AssetCollection {
+
+    pub source: Option<IRI>,
+    pub refinement: Vec<Constraint>,
+
+}
+
+impl AssetCollection {
+
+    pub fn new(source: Option<IRI>, refinement: Vec<Constraint>) -> AssetCollection {
+        AssetCollection {
+            source,
+            refinement,
+        }
+    }
+
+}
+
+#[derive(Debug, Clone)]
+pub struct Asset {
+
+    pub uid: Option<IRI>,
+    pub part_of: Vec<AssetCollection>,
+    pub relation: Relation,
+    pub has_policy: Option<Policy>, // Target Policy Property
+
+}
+
+impl Asset {
+
+    pub fn new(uid: Option<IRI>, part_of: Vec<AssetCollection>, relation: Relation, has_policy: Option<Policy>) -> Asset {
+        Asset {
+            uid,
+            part_of,
+            relation,
+            has_policy
+        }
+    }
+
+}

src/model/ConflictTerm.rs

@@ -0,0 +1,9 @@
+#[derive(Debug, PartialEq, Eq, Clone)]
+pub enum ConflictTerm {
+
+    Perm,
+    Prohibit,
+    Invalid,
+
+}
+

src/model/Constraint.rs

@@ -0,0 +1,99 @@
+use crate::model::TypeAlias::IRI;
+
+#[derive(Debug, Clone)]
+pub enum LeftOperand {
+
+    Literal(String),
+    IRI(IRI),
+    Reference(IRI),
+
+}
+
+#[derive(Debug, Clone)]
+pub enum Operator {
+
+    Equal,
+    NotEqual,
+    GreaterThan,
+    LessThan,
+    GreaterThanOrEqual,
+    LessThanOrEqual,
+
+}
+
+#[derive(Debug, Clone)]
+pub enum RightOperand {
+
+    Literal(String),
+    IRI(IRI),
+    Reference(IRI),
+
+}
+
+#[derive(Debug, Clone)]
+pub struct Constraint {
+
+    pub uid: Option<IRI>,
+    pub left_operand: LeftOperand,
+    pub operator: Operator,
+    pub right_operand: Option<RightOperand>,
+    pub data_type: Option<IRI>,
+    pub unit: Option<IRI>,
+    pub status: Option<IRI>,
+
+}
+
+impl Constraint {
+
+    pub fn new(
+        uid: Option<IRI>,
+        left_operand: LeftOperand,
+        operator: Operator,
+        right_operand: Option<RightOperand>,
+        data_type: Option<IRI>,
+        unit: Option<IRI>,
+        status: Option<IRI>,
+    ) -> Constraint {
+
+        Constraint {
+            uid,
+            left_operand,
+            operator,
+            right_operand,
+            data_type,
+            unit,
+            status,
+        }
+    }
+
+}
+
+#[derive(Debug, Clone)]
+pub enum LogicalOperator {
+
+    Or, // at least one of the Constraints MUST be satisfied
+    Xone, // only one, and not more, of the Constraints MUST be satisfied
+    And, // all of the Constraints MUST be satisfied
+    AndSequence, // all of the Constraints - in sequence - MUST be satisfied
+    // Add other logical operators as needed
+}
+
+#[derive(Debug, Clone)]
+pub struct LogicalConstraint {
+
+    pub uid: Option<IRI>,
+    pub operand: Option<(LogicalOperator, Vec<Constraint>)>,
+
+}
+
+impl LogicalConstraint {
+
+
+    pub fn new(uid: Option<IRI>, operand: Option<(LogicalOperator, Vec<Constraint>)>) -> LogicalConstraint {
+        LogicalConstraint {
+            uid,
+            operand
+        }
+    }
+
+}

src/model/Party.rs

@@ -0,0 +1,52 @@
+use crate::model::Constraint::Constraint;
+use crate::model::TypeAlias::IRI;
+
+
+#[derive(Debug, Clone)]
+pub struct Function {
+
+    pub assigner: Option<Box<Party>>,
+    pub assignee: Option<Box<Party>>,
+
+}
+
+#[derive(Debug, Clone)]
+pub struct Party {
+
+    pub uid: Option<IRI>,
+    pub part_of: Vec<PartyCollection>,
+    pub function: Function,
+
+}
+
+impl Party {
+
+    pub fn new(uid: Option<IRI>, part_of: Vec<PartyCollection>, function: Function) -> Party {
+        Party {
+            uid,
+            part_of,
+            function
+        }
+    }
+
+}
+
+
+#[derive(Debug, Clone)]
+pub struct PartyCollection {
+
+    pub source: Option<IRI>,
+    pub refinement: Vec<Constraint>,
+
+}
+
+impl PartyCollection {
+
+    pub fn new(source: Option<IRI>, refinement: Vec<Constraint>) -> PartyCollection {
+        PartyCollection {
+            source,
+            refinement
+        }
+    }
+
+}

src/model/Policy.rs

@@ -0,0 +1,122 @@
+use crate::model::Party::Party;
+use crate::model::Rule::*;
+use crate::model::ConflictTerm::ConflictTerm;
+use crate::model::Action::Action;
+use crate::model::TypeAlias::IRI;
+
+
+// A Policy MAY include an obligation to fulfil a Duty. The obligation is fulfilled if all constraints are satisfied and if its action, with all refinements satisfied, has been exercised.
+#[derive(Debug, Clone)]
+pub struct Obligation {
+
+    pub assigner: Party,
+    pub assignee: Party,
+    pub action: Action,
+    pub consequence: Vec<Duty>,
+
+}
+
+/// Default Policy of type Set
+#[derive(Debug, Clone)]
+pub struct SetPolicy {
+
+    pub uid: IRI,
+    pub rules: Vec<Rule>,
+    pub profiles: Vec<IRI>,
+    pub inherit_from: Vec<IRI>,
+    pub conflict: Option<ConflictTerm>,
+    pub obligation: Option<Vec<Obligation>>,
+
+}
+
+impl SetPolicy {
+
+    pub fn new(uid: IRI, rules: Vec<Rule>, profiles: Vec<IRI>, inherit_from: Vec<IRI>, conflict: Option<ConflictTerm>, obligation: Option<Vec<Obligation>>) -> Self {
+        SetPolicy {
+            uid,
+            rules,
+            profiles,
+            inherit_from,
+            conflict,
+            obligation
+        }
+    }
+
+}
+
+#[derive(Debug, Clone)]
+pub struct OfferPolicy {
+
+    pub uid: IRI,
+    pub assigner: Party,
+    pub rules: Vec<Rule>,
+    pub profiles: Vec<IRI>,
+    pub inherit_from: Vec<IRI>,
+    pub conflict: Option<ConflictTerm>,
+    pub obligation: Option<Vec<Obligation>>
+
+}
+
+impl OfferPolicy {
+
+    pub fn new(uid: IRI, assigner: Party, rules: Vec<Rule>, profiles: Vec<IRI>, inherit_from: Vec<IRI>, conflict: Option<ConflictTerm>, obligation: Option<Vec<Obligation>>) -> Self {
+        OfferPolicy {
+            uid,
+            assigner,
+            rules,
+            profiles,
+            inherit_from,
+            conflict,
+            obligation
+        }
+    }
+
+}
+
+#[derive(Debug, Clone)]
+pub struct AgreementPolicy {
+
+    pub uid: IRI,
+    pub assigner: Party,
+    pub assignee: Party,
+    pub rules: Vec<Rule>,
+    pub profiles: Vec<IRI>,
+    pub inherit_from: Vec<IRI>,
+    pub conflict: Option<ConflictTerm>,
+    pub obligation: Option<Vec<Obligation>>
+
+}
+
+impl AgreementPolicy {
+
+    pub fn new(uid: IRI, assigner: Party, assignee: Party, rules: Vec<Rule>, profiles: Vec<IRI>, inherit_from: Vec<IRI>, conflict: Option<ConflictTerm>, obligation: Option<Vec<Obligation>>) -> Self {
+        AgreementPolicy {
+            uid,
+            assigner,
+            assignee,
+            rules,
+            profiles,
+            inherit_from,
+            conflict,
+            obligation
+        }
+    }
+
+}
+
+
+#[derive(Debug, Clone)]
+pub enum Policy {
+
+    SetPolicy(SetPolicy),
+    OfferPolicy(OfferPolicy),
+    AgreementPolicy(AgreementPolicy),
+
+}
+
+impl Default for Policy {
+    fn default() -> Self {
+        // Default to SetPolicy
+        Policy::SetPolicy(SetPolicy::new("default_policy".to_string(), vec![], vec![], vec![], None, None))
+    }
+}

src/model/Rule.rs

@@ -0,0 +1,153 @@
+use crate::model::Action::Action;
+use crate::model::Asset::Asset;
+use crate::model::Party::Party;
+use crate::model::Constraint::Constraint;
+use crate::model::TypeAlias::IRI;
+
+
+#[derive(Debug, Clone)]
+pub enum Rule {
+
+    Permission(Permission),
+    Prohibition(Prohibition),
+    Duty(Duty),
+
+}
+
+
+#[derive(Debug, Clone)]
+pub struct Permission {
+
+    pub uid: Option<IRI>,
+    pub action: Action,
+    pub relation: Option<Asset>,
+    pub function: Vec<Party>,
+    pub failures: Vec<Rule>,
+    pub constraints: Vec<Constraint>,
+
+    pub target: Asset,
+    pub assigner: Option<Party>,
+    pub assignee: Option<Party>,
+    pub duties: Vec<Duty>,
+
+}
+
+impl Permission {
+
+    pub fn new(uid: Option<IRI>, action: Action, relation: Option<Asset>, function: Vec<Party>, failures: Vec<Rule>, constraints: Vec<Constraint>, target: Asset, assigner: Option<Party>, assignee: Option<Party>, duties: Vec<Duty>) -> Self {
+        Permission {
+            uid,
+            action,
+            relation,
+            function,
+            failures,
+            constraints,
+            target,
+            assigner,
+            assignee,
+            duties
+        }
+    }
+
+}
+
+
+#[derive(Debug, Clone)]
+pub struct Prohibition {
+
+    pub uid: Option<IRI>,
+    pub action: Action,
+    pub relation: Option<Asset>,
+    pub function: Vec<Party>,
+    pub failures: Vec<Rule>,
+    pub constraints: Vec<Constraint>,
+
+    pub target: Asset,
+    pub assigner: Option<Party>,
+    pub assignee: Option<Party>,
+    pub remedies: Vec<Duty>,
+
+}
+
+impl Prohibition {
+
+    pub fn new(uid: Option<IRI>, action: Action, relation: Option<Asset>, function: Vec<Party>, failures: Vec<Rule>, constraints: Vec<Constraint>, target: Asset, assigner: Option<Party>, assignee: Option<Party>, remedies: Vec<Duty>) -> Self {
+        Prohibition {
+            uid,
+            action,
+            relation,
+            function,
+            failures,
+            constraints,
+            target,
+            assigner,
+            assignee,
+            remedies
+        }
+    }
+}
+
+
+#[derive(Debug, Clone)]
+pub struct Duty {
+
+    pub uid: Option<IRI>,
+    pub action: Action,
+    pub relation: Option<Asset>,
+    pub failures: Vec<Rule>,
+    pub constraints: Vec<Constraint>,
+
+    pub target: Option<Asset>,
+    pub assigner: Option<Party>,
+    pub assignee: Option<Party>,
+    pub consequences: Vec<Duty>,
+    pub pre_condition: Option<Vec<Duty>>,
+    pub function: Option<Vec<Party>>,
+
+}
+
+impl Duty {
+
+    pub fn new(uid: Option<IRI>, action: Action, relation: Option<Asset>, failures: Vec<Rule>, constraints: Vec<Constraint>, target: Option<Asset>, assigner: Option<Party>, assignee: Option<Party>, consequences: Vec<Duty>, pre_condition: Option<Vec<Duty>>, function: Option<Vec<Party>>) -> Self {
+        Duty {
+            uid,
+            action,
+            relation,
+            failures,
+            constraints,
+            target,
+            assigner,
+            assignee,
+            consequences,
+            pre_condition,
+            function
+        }
+    }
+
+}
+
+
+#[derive(Debug, Clone)]
+pub struct Agreement {
+    uid: IRI,
+    profile: IRI,
+    conflict: Option<String>,
+    permission: Option<Vec<Permission>>,
+    prohibition: Option<Vec<Prohibition>>,
+    // Add other properties specific to Agreement as needed
+}
+
+impl Agreement {
+
+    pub fn new(uid: IRI, profile: IRI, conflict: Option<String>, permission: Option<Vec<Permission>>, prohibition: Option<Vec<Prohibition>>) -> Self {
+        Agreement {
+            uid,
+            profile,
+            conflict,
+            permission,
+            prohibition,
+        }
+    }
+
+}
+

src/model/TypeAlias.rs

@@ -0,0 +1 @@
+pub type IRI = String;

src/model/mod.rs

@@ -0,0 +1,8 @@
+pub mod Action;
+pub mod Asset;
+pub mod ConflictTerm;
+pub mod Constraint;
+pub mod Party;
+pub mod Policy;
+pub mod Rule;
+pub mod TypeAlias;