use std::collections::BTreeMap;
use serde::{Deserialize, Serialize};
use crate::extension::ExtensionValue;
use crate::geometry::{Matrix4, Placement, Rotation, Vector3};
use crate::quantity::Quantity;
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub enum Property {
String(String),
Float(f64),
Bool(bool),
Integer(i64),
Quantity(Quantity),
FloatList(Vec<f64>),
IntegerList(Vec<i64>),
StringList(Vec<String>),
BoolList(Vec<bool>),
Vector(Vector3),
VectorList(Vec<Vector3>),
Placement(Placement),
PlacementList(Vec<Placement>),
Rotation(Rotation),
RotationList(Vec<Rotation>),
Matrix(Matrix4),
Link(String),
LinkList(Vec<String>),
LinkSub(String, Vec<String>),
ColorList(Vec<[f64; 4]>),
PythonObject(String),
FileIncluded(String),
IntPairList(Vec<(i64, i64)>),
Enumeration(Vec<String>, usize),
IntegerConstraint {
value: i64,
min: i64,
max: i64,
step: i64,
},
FloatConstraint {
value: f64,
min: f64,
max: f64,
step: f64,
},
Extension(ExtensionValue),
}
impl Property {
pub fn type_name(&self) -> &str {
match self {
Property::String(_) => "App::PropertyString",
Property::Float(_) => "App::PropertyFloat",
Property::Bool(_) => "App::PropertyBool",
Property::Integer(_) => "App::PropertyInteger",
Property::Quantity(_) => "App::PropertyLength",
Property::FloatList(_) => "App::PropertyFloatList",
Property::IntegerList(_) => "App::PropertyIntegerList",
Property::StringList(_) => "App::PropertyStringList",
Property::BoolList(_) => "App::PropertyBoolList",
Property::Vector(_) => "App::PropertyVector",
Property::VectorList(_) => "App::PropertyVectorList",
Property::Placement(_) => "App::PropertyPlacement",
Property::PlacementList(_) => "App::PropertyPlacementList",
Property::Rotation(_) => "App::PropertyRotation",
Property::RotationList(_) => "App::PropertyRotationList",
Property::Matrix(_) => "App::PropertyMatrix",
Property::Link(_) => "App::PropertyLink",
Property::LinkList(_) => "App::PropertyLinkList",
Property::LinkSub(_, _) => "App::PropertyLinkSub",
Property::ColorList(_) => "App::PropertyColorList",
Property::PythonObject(_) => "App::PropertyPythonObject",
Property::FileIncluded(_) => "App::PropertyFileIncluded",
Property::IntPairList(_) => "App::PropertyIntPairList",
Property::Enumeration(_, _) => "App::PropertyEnumeration",
Property::IntegerConstraint { .. } => "App::PropertyIntegerConstraint",
Property::FloatConstraint { .. } => "App::PropertyFloatConstraint",
Property::Extension(value) => value.type_name(),
}
}
}
pub mod prop_status {
pub const NONE: u32 = 0;
pub const READONLY: u32 = 1;
pub const TRANSIENT: u32 = 2;
pub const HIDDEN: u32 = 4;
pub const OUTPUT: u32 = 8;
pub const NORECOMPUTE: u32 = 16;
pub const NOPERSIST: u32 = 32;
pub const INPUT: u32 = 64;
pub const DYNAMIC: u32 = 128;
pub const NOT_PERSISTED: u32 = NOPERSIST;
}
pub fn status_names(status: u32) -> Vec<&'static str> {
let mut names = Vec::new();
if status & prop_status::HIDDEN != 0 {
names.push("Hidden");
}
if status & prop_status::NORECOMPUTE != 0 {
names.push("NoRecompute");
}
if status & prop_status::NOPERSIST != 0 {
names.push("NoPersist");
}
if status & prop_status::OUTPUT != 0 {
names.push("Output");
}
if status & prop_status::READONLY != 0 {
names.push("ReadOnly");
}
if status & prop_status::TRANSIENT != 0 {
names.push("Transient");
}
if status & prop_status::INPUT != 0 {
names.push("Input");
}
names
}
pub fn status_from_name(name: &str) -> Option<u32> {
match name.to_ascii_lowercase().as_str() {
"readonly" => Some(prop_status::READONLY),
"transient" => Some(prop_status::TRANSIENT),
"hidden" => Some(prop_status::HIDDEN),
"output" => Some(prop_status::OUTPUT),
"norecompute" => Some(prop_status::NORECOMPUTE),
"nopersist" => Some(prop_status::NOPERSIST),
"input" => Some(prop_status::INPUT),
_ => None,
}
}
#[derive(Debug, Default)]
pub struct PropertyContainer {
props: BTreeMap<String, Property>,
status: BTreeMap<String, u32>,
group: BTreeMap<String, String>,
doc: BTreeMap<String, String>,
}
impl PropertyContainer {
pub fn new() -> Self {
Self::default()
}
pub fn set(&mut self, name: impl Into<String>, value: Property) {
let name = name.into();
self.status.entry(name.clone()).or_insert(prop_status::NONE);
self.props.insert(name, value);
}
pub fn set_with_status(&mut self, name: impl Into<String>, value: Property, status: u32) {
let name = name.into();
self.status.insert(name.clone(), status);
self.props.insert(name, value);
}
pub fn status(&self, name: &str) -> Option<u32> {
self.status.get(name).map(|s| s & !prop_status::DYNAMIC)
}
pub fn raw_status(&self, name: &str) -> Option<u32> {
self.status.get(name).copied()
}
pub fn set_meta(&mut self, name: impl Into<String>, group: &str, doc: &str) {
let name = name.into();
self.group.insert(name.clone(), group.to_string());
self.doc.insert(name, doc.to_string());
}
pub fn group(&self, name: &str) -> Option<&str> {
self.props.contains_key(name).then(|| {
self.group.get(name).map(String::as_str).unwrap_or("")
})
}
pub fn doc(&self, name: &str) -> Option<&str> {
self.props.contains_key(name).then(|| {
self.doc.get(name).map(String::as_str).unwrap_or("")
})
}
pub fn set_status(&mut self, name: &str, status: u32) -> Option<u32> {
if !self.props.contains_key(name) {
return None;
}
let prev = self.status.get(name).copied().unwrap_or(prop_status::NONE);
let dynamic = prev & prop_status::DYNAMIC;
let new = (status & !prop_status::DYNAMIC) | dynamic;
self.status.insert(name.to_string(), new);
Some(prev & !prop_status::DYNAMIC)
}
pub fn get(&self, name: &str) -> Option<&Property> {
self.props.get(name)
}
pub fn get_mut(&mut self, name: &str) -> Option<&mut Property> {
self.props.get_mut(name)
}
pub fn remove(&mut self, name: &str) -> Option<Property> {
self.status.remove(name);
self.group.remove(name);
self.doc.remove(name);
self.props.remove(name)
}
pub fn clear(&mut self) {
self.props.clear();
self.status.clear();
self.group.clear();
self.doc.clear();
}
pub fn iter(&self) -> impl Iterator<Item = (&String, &Property)> {
self.props.iter()
}
pub fn len(&self) -> usize {
self.props.len()
}
pub fn is_empty(&self) -> bool {
self.props.is_empty()
}
pub fn names(&self) -> impl Iterator<Item = &String> {
self.props.keys()
}
}