///|
const XBRL_DIMENSIONS_NS : String = "http://xbrl.org/2006/xbrldi"
///|
pub(all) enum DimensionMember {
Explicit(QName, QName)
Typed(QName, QName, String)
} derive(Eq, @debug.Debug)
///|
pub fn DimensionMember::dimension(self : DimensionMember) -> QName {
match self {
Explicit(dimension, _) => dimension
Typed(dimension, _, _) => dimension
}
}
///|
fn dimension_has(dimensions : Array[QName], dimension : QName) -> Bool {
for existing in dimensions {
if existing == dimension {
return true
}
}
false
}
///|
fn required_dimension_attribute(node : XmlNode) -> Result[QName, XbrlError] {
let lexical = match node.attribute("", "dimension") {
Some(value) if value.trim().length() > 0 => value.trim()
_ =>
return Err(
InvalidDimension("dimension attribute is required", node.offset),
)
}
resolve_qname(lexical, node.namespaces, true)
}
///|
fn parse_dimension_container(
container : XmlNode?,
seen : Array[QName],
) -> Result[Array[DimensionMember], XbrlError] {
let result : Array[DimensionMember] = []
let node = match container {
Some(value) => value
None => return Ok(result)
}
for child in node.children {
if child.name.matches(XBRL_DIMENSIONS_NS, "explicitMember") {
let dimension = match required_dimension_attribute(child) {
Ok(value) => value
Err(err) => return Err(err)
}
if dimension_has(seen, dimension) {
return Err(
InvalidDimension("duplicate explicit dimension", child.offset),
)
}
if child.children.length() > 0 {
return Err(
InvalidDimension(
"explicitMember cannot contain child elements",
child.offset,
),
)
}
let lexical = child.text.trim()
if lexical.length() == 0 {
return Err(
InvalidDimension("explicitMember value is empty", child.offset),
)
}
let dimension_value = match
resolve_qname(lexical, child.namespaces, true) {
Ok(value) => value
Err(err) => return Err(err)
}
seen.push(dimension)
result.push(Explicit(dimension, dimension_value))
} else if child.name.matches(XBRL_DIMENSIONS_NS, "typedMember") {
let dimension = match required_dimension_attribute(child) {
Ok(value) => value
Err(err) => return Err(err)
}
if dimension_has(seen, dimension) {
return Err(InvalidDimension("duplicate typed dimension", child.offset))
}
if child.children.length() != 1 {
return Err(
InvalidDimension(
"typedMember requires exactly one member element",
child.offset,
),
)
}
let child_member = child.children[0]
seen.push(dimension)
result.push(Typed(dimension, child_member.name, child_member.text))
}
}
Ok(result)
}
///|
pub fn parse_context_dimensions(
segment : XmlNode?,
scenario : XmlNode?,
) -> Result[Array[DimensionMember], XbrlError] {
let seen : Array[QName] = []
let result : Array[DimensionMember] = []
let segment_members = match parse_dimension_container(segment, seen) {
Ok(value) => value
Err(err) => return Err(err)
}
for item in segment_members {
result.push(item)
}
let scenario_members = match parse_dimension_container(scenario, seen) {
Ok(value) => value
Err(err) => return Err(err)
}
for item in scenario_members {
result.push(item)
}
Ok(result)
}
///|
pub fn XbrlContext::dimension(
self : XbrlContext,
dimension : QName,
) -> DimensionMember? {
for item in self.dimensions {
if item.dimension() == dimension {
return Some(item)
}
}
None
}
///|
pub extend DimensionMember with Eq::{not_equal, equal}
///|
pub extend DimensionMember with @debug.Debug::{to_repr}