221 lines
6.0 KiB
Elixir
221 lines
6.0 KiB
Elixir
defmodule RDF.XSD.Decimal do
|
|
@moduledoc """
|
|
`RDF.XSD.Datatype` for XSD decimals.
|
|
"""
|
|
|
|
@type valid_value :: Decimal.t()
|
|
|
|
use RDF.XSD.Datatype.Primitive,
|
|
name: "decimal",
|
|
id: RDF.Utils.Bootstrapping.xsd_iri("decimal")
|
|
|
|
alias RDF.XSD
|
|
alias Elixir.Decimal, as: D
|
|
|
|
def_applicable_facet XSD.Facets.MinInclusive
|
|
def_applicable_facet XSD.Facets.MaxInclusive
|
|
def_applicable_facet XSD.Facets.MinExclusive
|
|
def_applicable_facet XSD.Facets.MaxExclusive
|
|
def_applicable_facet XSD.Facets.TotalDigits
|
|
def_applicable_facet XSD.Facets.FractionDigits
|
|
def_applicable_facet XSD.Facets.Pattern
|
|
|
|
@doc false
|
|
def min_inclusive_conform?(min_inclusive, value, _lexical) do
|
|
not (D.cmp(value, D.new(min_inclusive)) == :lt)
|
|
end
|
|
|
|
@doc false
|
|
def max_inclusive_conform?(max_inclusive, value, _lexical) do
|
|
not (D.cmp(value, D.new(max_inclusive)) == :gt)
|
|
end
|
|
|
|
@doc false
|
|
def min_exclusive_conform?(min_exclusive, value, _lexical) do
|
|
D.cmp(value, D.new(min_exclusive)) == :gt
|
|
end
|
|
|
|
@doc false
|
|
def max_exclusive_conform?(max_exclusive, value, _lexical) do
|
|
D.cmp(value, D.new(max_exclusive)) == :lt
|
|
end
|
|
|
|
@doc false
|
|
def total_digits_conform?(total_digits, value, _lexical) do
|
|
do_digit_count(to_string(value)) <= total_digits
|
|
end
|
|
|
|
@doc false
|
|
def fraction_digits_conform?(fraction_digits, value, _lexical) do
|
|
do_fraction_digit_count(to_string(value)) <= fraction_digits
|
|
end
|
|
|
|
@doc false
|
|
def pattern_conform?(pattern, _value, lexical) do
|
|
XSD.Facets.Pattern.conform?(pattern, lexical)
|
|
end
|
|
|
|
@impl XSD.Datatype
|
|
def lexical_mapping(lexical, opts) do
|
|
if String.contains?(lexical, ~w[e E]) do
|
|
@invalid_value
|
|
else
|
|
case D.parse(lexical) do
|
|
{:ok, decimal} -> elixir_mapping(decimal, opts)
|
|
:error -> @invalid_value
|
|
end
|
|
end
|
|
end
|
|
|
|
@impl XSD.Datatype
|
|
@spec elixir_mapping(valid_value | integer | float | any, Keyword.t()) :: value
|
|
def elixir_mapping(value, _)
|
|
|
|
def elixir_mapping(%D{coef: coef}, _) when coef in ~w[qNaN sNaN inf]a,
|
|
do: @invalid_value
|
|
|
|
def elixir_mapping(%D{} = decimal, _),
|
|
do: canonical_decimal(decimal)
|
|
|
|
def elixir_mapping(value, opts) when is_integer(value),
|
|
do: value |> D.new() |> elixir_mapping(opts)
|
|
|
|
def elixir_mapping(value, opts) when is_float(value),
|
|
do: value |> D.from_float() |> elixir_mapping(opts)
|
|
|
|
def elixir_mapping(_, _), do: @invalid_value
|
|
|
|
@doc false
|
|
@spec canonical_decimal(valid_value) :: valid_value
|
|
def canonical_decimal(decimal)
|
|
|
|
def canonical_decimal(%D{coef: 0} = decimal),
|
|
do: %{decimal | exp: -1}
|
|
|
|
def canonical_decimal(%D{coef: coef, exp: 0} = decimal),
|
|
do: %{decimal | coef: coef * 10, exp: -1}
|
|
|
|
def canonical_decimal(%D{coef: coef, exp: exp} = decimal)
|
|
when exp > 0,
|
|
do: canonical_decimal(%{decimal | coef: coef * 10, exp: exp - 1})
|
|
|
|
def canonical_decimal(%D{coef: coef} = decimal)
|
|
when Kernel.rem(coef, 10) != 0,
|
|
do: decimal
|
|
|
|
def canonical_decimal(%D{coef: coef, exp: exp} = decimal),
|
|
do: canonical_decimal(%{decimal | coef: Kernel.div(coef, 10), exp: exp + 1})
|
|
|
|
@impl XSD.Datatype
|
|
@spec canonical_mapping(valid_value) :: String.t()
|
|
def canonical_mapping(value)
|
|
|
|
def canonical_mapping(%D{sign: sign, coef: :qNaN}),
|
|
do: if(sign == 1, do: "NaN", else: "-NaN")
|
|
|
|
def canonical_mapping(%D{sign: sign, coef: :sNaN}),
|
|
do: if(sign == 1, do: "sNaN", else: "-sNaN")
|
|
|
|
def canonical_mapping(%D{sign: sign, coef: :inf}),
|
|
do: if(sign == 1, do: "Infinity", else: "-Infinity")
|
|
|
|
def canonical_mapping(%D{} = decimal),
|
|
do: D.to_string(decimal, :normal)
|
|
|
|
@impl RDF.Literal.Datatype
|
|
def do_cast(value)
|
|
|
|
def do_cast(%XSD.String{} = xsd_string) do
|
|
xsd_string.value |> new() |> canonical()
|
|
end
|
|
|
|
def do_cast(literal) do
|
|
cond do
|
|
XSD.Boolean.datatype?(literal) ->
|
|
case literal.value do
|
|
false -> new(0.0)
|
|
true -> new(1.0)
|
|
end
|
|
|
|
XSD.Integer.datatype?(literal) ->
|
|
new(literal.value)
|
|
|
|
# we're catching XSD.Floats with this too
|
|
is_float(literal.value) and XSD.Double.datatype?(literal) ->
|
|
new(literal.value)
|
|
|
|
true ->
|
|
super(literal)
|
|
end
|
|
end
|
|
|
|
@impl RDF.Literal.Datatype
|
|
def do_equal_value_same_or_derived_datatypes?(left, right),
|
|
do: XSD.Numeric.do_equal_value?(left, right)
|
|
|
|
@impl RDF.Literal.Datatype
|
|
def do_equal_value_different_datatypes?(left, right),
|
|
do: XSD.Numeric.do_equal_value?(left, right)
|
|
|
|
@impl RDF.Literal.Datatype
|
|
def do_compare(left, right), do: XSD.Numeric.do_compare(left, right)
|
|
|
|
@doc """
|
|
The number of digits in the XML Schema canonical form of the literal value.
|
|
"""
|
|
@spec digit_count(RDF.Literal.t()) :: non_neg_integer | nil
|
|
def digit_count(literal)
|
|
def digit_count(%RDF.Literal{literal: datatype_literal}), do: digit_count(datatype_literal)
|
|
|
|
def digit_count(%datatype{} = literal) do
|
|
cond do
|
|
XSD.Integer.datatype?(datatype) ->
|
|
XSD.Integer.digit_count(literal)
|
|
|
|
datatype?(datatype) and datatype.valid?(literal) ->
|
|
literal
|
|
|> datatype.canonical_lexical()
|
|
|> do_digit_count()
|
|
|
|
true ->
|
|
nil
|
|
end
|
|
end
|
|
|
|
@doc false
|
|
def do_digit_count(decimal_string) do
|
|
decimal_string
|
|
|> String.replace(".", "")
|
|
|> String.replace("-", "")
|
|
|> String.length()
|
|
end
|
|
|
|
@doc """
|
|
The number of digits to the right of the decimal point in the XML Schema canonical form of the literal value.
|
|
"""
|
|
@spec fraction_digit_count(RDF.Literal.t()) :: non_neg_integer | nil
|
|
def fraction_digit_count(%RDF.Literal{literal: datatype_literal}),
|
|
do: fraction_digit_count(datatype_literal)
|
|
|
|
def fraction_digit_count(%datatype{} = literal) do
|
|
cond do
|
|
XSD.Integer.datatype?(literal) ->
|
|
0
|
|
|
|
datatype?(literal) and datatype.valid?(literal) ->
|
|
literal
|
|
|> datatype.canonical_lexical()
|
|
|> do_fraction_digit_count()
|
|
|
|
true ->
|
|
nil
|
|
end
|
|
end
|
|
|
|
@doc false
|
|
def do_fraction_digit_count(decimal_string) do
|
|
[_, fraction] = String.split(decimal_string, ".")
|
|
String.length(fraction)
|
|
end
|
|
end
|