///|
pub struct Point {
x : Double
y : Double
}
///|
pub struct EdgeObj {
v : String
w : String
name : String?
}
///|
pub enum Attr {
Bool(Bool)
Int(Int32)
Float(Double)
String(String)
Val(Value)
Point(Point)
Points(Array[Point])
Edge(EdgeObj)
Edges(Array[EdgeObj])
Strings(Array[String])
Ints(Array[Int32])
}
///|
pub struct Attrs {
map : Map[String, Attr]
}
///|
pub enum Value {
VNull
VBool(Bool)
VInt(Int32)
VFloat(Double)
VString(String)
VAttrs(Attrs)
}
///|
pub fn point(x : Double, y : Double) -> Point {
{ x, y, }
}
///|
pub fn edge_obj(v : String, w : String, name? : String) -> EdgeObj {
{ v, w, name, }
}
///|
pub fn empty_attrs() -> Attrs {
{ map: Map([]), }
}
///|
pub fn clone_attrs(attrs : Attrs) -> Attrs {
{ map: attrs.map.copy(), }
}
///|
pub fn attrs_value(attrs : Attrs) -> Value {
VAttrs(attrs)
}
///|
pub fn value_null() -> Value {
VNull
}
///|
pub fn value_bool(v : Bool) -> Value {
VBool(v)
}
///|
pub fn value_int(v : Int32) -> Value {
VInt(v)
}
///|
pub fn value_float(v : Double) -> Value {
VFloat(v)
}
///|
pub fn value_string(v : String) -> Value {
VString(v)
}
///|
pub fn clone_value(value : Value) -> Value {
match value {
VNull => VNull
VBool(v) => VBool(v)
VInt(v) => VInt(v)
VFloat(v) => VFloat(v)
VString(v) => VString(v)
VAttrs(attrs) => VAttrs(clone_attrs(attrs))
}
}
///|
pub fn value_as_attrs(value : Value?) -> Attrs? {
match value {
Some(VAttrs(attrs)) => Some(attrs)
_ => None
}
}
///|
pub fn value_as_int(value : Value?) -> Int32? {
match value {
Some(VInt(v)) => Some(v)
Some(VFloat(v)) => Some(v.to_int())
_ => None
}
}
///|
pub fn value_as_float(value : Value?) -> Double? {
match value {
Some(VInt(v)) => Some(v.to_double())
Some(VFloat(v)) => Some(v)
_ => None
}
}
///|
pub fn value_as_string(value : Value?) -> String? {
match value {
Some(VString(v)) => Some(v)
_ => None
}
}
///|
pub fn value_as_bool(value : Value?) -> Bool? {
match value {
Some(VBool(v)) => Some(v)
_ => None
}
}
///|
pub fn Attrs::contains(self : Attrs, key : String) -> Bool {
self.map.contains(key)
}
///|
pub fn Attrs::remove(self : Attrs, key : String) -> Unit {
self.map.remove(key)
}
///|
pub fn Attrs::get(self : Attrs, key : String) -> Attr? {
self.map.get(key)
}
///|
pub fn Attrs::set(self : Attrs, key : String, value : Attr) -> Unit {
if attr_references_attrs(value, self) {
abort("Cannot create a cyclic attribute value")
}
self.map.set(key, value)
}
///|
fn attr_references_attrs(value : Attr, target : Attrs) -> Bool {
match value {
Val(value) => value_references_attrs(value, target, [])
_ => false
}
}
///|
fn value_references_attrs(
value : Value,
target : Attrs,
visited : Array[Attrs],
) -> Bool {
match value {
VAttrs(attrs) => attrs_references_attrs(attrs, target, visited)
_ => false
}
}
///|
fn attrs_references_attrs(
attrs : Attrs,
target : Attrs,
visited : Array[Attrs],
) -> Bool {
if physical_equal(attrs.map, target.map) {
return true
}
for seen in visited {
if physical_equal(attrs.map, seen.map) {
return false
}
}
visited.push(attrs)
for key in attrs.keys() {
if attrs.get(key) is Some(value) &&
attr_references_attrs_with_visited(value, target, visited) {
return true
}
}
false
}
///|
fn attr_references_attrs_with_visited(
value : Attr,
target : Attrs,
visited : Array[Attrs],
) -> Bool {
match value {
Val(value) => value_references_attrs(value, target, visited)
_ => false
}
}
///|
pub fn Attrs::keys(self : Attrs) -> Array[String] {
self.map.keys().to_array()
}
///|
pub fn Attrs::length(self : Attrs) -> Int32 {
self.map.length()
}
///|
pub fn Attrs::set_int(self : Attrs, key : String, value : Int32) -> Unit {
self.set(key, Int(value))
}
///|
pub fn Attrs::set_float(self : Attrs, key : String, value : Double) -> Unit {
self.set(key, Float(value))
}
///|
pub fn Attrs::set_bool(self : Attrs, key : String, value : Bool) -> Unit {
self.set(key, Bool(value))
}
///|
pub fn Attrs::set_string(self : Attrs, key : String, value : String) -> Unit {
self.set(key, String(value))
}
///|
pub fn Attrs::set_point(self : Attrs, key : String, value : Point) -> Unit {
self.set(key, Point(value))
}
///|
pub fn Attrs::set_value(self : Attrs, key : String, value : Value) -> Unit {
self.set(key, Val(value))
}
///|
pub fn Attrs::set_points(
self : Attrs,
key : String,
value : Array[Point],
) -> Unit {
self.set(key, Points(value))
}
///|
pub fn Attrs::set_edge(self : Attrs, key : String, value : EdgeObj) -> Unit {
self.set(key, Edge(value))
}
///|
pub fn Attrs::set_edges(
self : Attrs,
key : String,
value : Array[EdgeObj],
) -> Unit {
self.set(key, Edges(value))
}
///|
pub fn Attrs::set_strings(
self : Attrs,
key : String,
value : Array[String],
) -> Unit {
self.set(key, Strings(value))
}
///|
pub fn Attrs::set_ints(
self : Attrs,
key : String,
value : Array[Int32],
) -> Unit {
self.set(key, Ints(value))
}
///|
pub fn Attrs::get_int(self : Attrs, key : String) -> Int32? {
match self.get(key) {
Some(Int(v)) => Some(v)
Some(Float(v)) => Some(v.to_int())
_ => None
}
}
///|
pub fn Attrs::get_float(self : Attrs, key : String) -> Double? {
match self.get(key) {
Some(Int(v)) => Some(v.to_double())
Some(Float(v)) => Some(v)
_ => None
}
}
///|
pub fn Attrs::get_bool(self : Attrs, key : String) -> Bool? {
match self.get(key) {
Some(Bool(v)) => Some(v)
_ => None
}
}
///|
pub fn Attrs::get_string(self : Attrs, key : String) -> String? {
match self.get(key) {
Some(String(v)) => Some(v)
_ => None
}
}
///|
pub fn Attrs::get_point(self : Attrs, key : String) -> Point? {
match self.get(key) {
Some(Point(v)) => Some(v)
_ => None
}
}
///|
pub fn Attrs::get_value(self : Attrs, key : String) -> Value? {
match self.get(key) {
Some(Val(v)) => Some(v)
_ => None
}
}
///|
pub fn Attrs::get_points(self : Attrs, key : String) -> Array[Point]? {
match self.get(key) {
Some(Points(v)) => Some(v)
_ => None
}
}
///|
pub fn Attrs::get_edge(self : Attrs, key : String) -> EdgeObj? {
match self.get(key) {
Some(Edge(v)) => Some(v)
_ => None
}
}
///|
pub fn Attrs::get_edges(self : Attrs, key : String) -> Array[EdgeObj]? {
match self.get(key) {
Some(Edges(v)) => Some(v)
_ => None
}
}
///|
pub fn Attrs::get_strings(self : Attrs, key : String) -> Array[String]? {
match self.get(key) {
Some(Strings(v)) => Some(v)
_ => None
}
}
///|
pub fn Attrs::get_ints(self : Attrs, key : String) -> Array[Int32]? {
match self.get(key) {
Some(Ints(v)) => Some(v)
_ => None
}
}
///|
pub fn Attrs::get_int_or(self : Attrs, key : String, fallback : Int32) -> Int32 {
if self.get_int(key) is Some(v) {
v
} else {
fallback
}
}
///|
pub fn Attrs::get_float_or(
self : Attrs,
key : String,
fallback : Double,
) -> Double {
if self.get_float(key) is Some(v) {
v
} else {
fallback
}
}
///|
pub fn Attrs::get_string_or(
self : Attrs,
key : String,
fallback : String,
) -> String {
if self.get_string(key) is Some(v) {
v
} else {
fallback
}
}
///|
pub fn Attrs::get_bool_or(self : Attrs, key : String, fallback : Bool) -> Bool {
if self.get_bool(key) is Some(v) {
v
} else {
fallback
}
}