GitHub

TOML

TOML.jl es una biblioteca estándar de Julia para analizar y escribir TOML v1.0 archivos.

Parsing TOML data

julia> using TOML

julia> data = """
           [database]
           server = "192.168.1.1"
           ports = [ 8001, 8001, 8002 ]
       """;

julia> TOML.parse(data)
Dict{String, Any} with 1 entry:
  "database" => Dict{String, Any}("server"=>"192.168.1.1", "ports"=>[8001, 8001…

Para analizar un archivo, utiliza TOML.parsefile. Si el archivo tiene un error de sintaxis, se lanza una excepción:

julia> using TOML

julia> TOML.parse("""
           value = 0.0.0
       """)
ERROR: TOML Parser error:
none:1:16 error: failed to parse value
      value = 0.0.0
                 ^
[...]

Hay otras versiones de las funciones de análisis (TOML.tryparse y TOML.tryparsefile) que en lugar de lanzar excepciones en caso de error de análisis devuelven un TOML.ParserError con información:

julia> using TOML

julia> err = TOML.tryparse("""
           value = 0.0.0
       """);

julia> err.type
ErrGenericValueError::ErrorType = 14

julia> err.line
1

julia> err.column
16

Exporting data to TOML file

La función TOML.print se utiliza para imprimir (o serializar) datos en formato TOML.

julia> using TOML

julia> data = Dict(
          "names" => ["Julia", "Julio"],
          "age" => [10, 20],
       );

julia> TOML.print(data)
names = ["Julia", "Julio"]
age = [10, 20]

julia> fname = tempname();

julia> open(fname, "w") do io
           TOML.print(io, data)
       end

julia> TOML.parsefile(fname)
Dict{String, Any} with 2 entries:
  "names" => ["Julia", "Julio"]
  "age"   => [10, 20]

Las claves se pueden ordenar según algún valor.

julia> using TOML

julia> TOML.print(Dict(
       "abc"  => 1,
       "ab"   => 2,
       "abcd" => 3,
       ); sorted=true, by=length)
ab = 2
abc = 1
abcd = 3

Para estructuras personalizadas, pasa una función que convierta la estructura a un tipo compatible.

julia> using TOML

julia> struct MyStruct
           a::Int
           b::String
       end

julia> TOML.print(Dict("foo" => MyStruct(5, "bar"))) do x
           x isa MyStruct && return [x.a, x.b]
           error("unhandled type $(typeof(x))")
       end
foo = [5, "bar"]

References

TOML.parse — Function
parse(x::Union{AbstractString, IO})
parse(p::Parser, x::Union{AbstractString, IO})

Analiza la cadena o flujo x, y devuelve la tabla resultante (diccionario). Lanza un ParserError en caso de fallo.

Ver también TOML.tryparse.

source
TOML.parsefile — Function
parsefile(f::AbstractString)
parsefile(p::Parser, f::AbstractString)

Analiza el archivo f y devuelve la tabla resultante (diccionario). Lanza un ParserError en caso de fallo.

Véase también TOML.tryparsefile.

source
TOML.tryparse — Function
tryparse(x::Union{AbstractString, IO})
tryparse(p::Parser, x::Union{AbstractString, IO})

Analiza la cadena o flujo x, y devuelve la tabla resultante (diccionario). Devuelve un ParserError en caso de fallo.

Ver también TOML.parse.

source
TOML.tryparsefile — Function
tryparsefile(f::AbstractString)
tryparsefile(p::Parser, f::AbstractString)

Analiza el archivo f y devuelve la tabla resultante (diccionario). Devuelve un ParserError en caso de fallo.

Ver también TOML.parsefile.

source
TOML.print — Function
print([to_toml::Function], io::IO [=stdout], data::AbstractDict; sorted=false, by=identity, inline_tables::IdSet{<:AbstractDict})

Escribe data en sintaxis TOML en el flujo io. Si el argumento clave sorted se establece en true, ordena las tablas de acuerdo con la función dada por el argumento clave by. Si se proporciona el argumento clave inline_tables, debe ser un conjunto de tablas que se deben imprimir "en línea".

Los siguientes tipos de datos son compatibles: AbstractDict, AbstractVector, AbstractString, Integer, AbstractFloat, Bool, Dates.DateTime, Dates.Time, Dates.Date. Ten en cuenta que los enteros y flotantes deben ser convertibles a Float64 e Int64 respectivamente. Para otros tipos de datos, pasa la función to_toml que toma los tipos de datos y devuelve un valor de un tipo compatible.

source
TOML.Parser — Type
Parser()

Constructor para un Parser de TOML. Tenga en cuenta que en la mayoría de los casos no es necesario crear explícitamente un Parser, sino que se utiliza directamente TOML.parsefile o TOML.parse. Sin embargo, usar un parser explícito reutilizará algunas estructuras de datos internas, lo que puede ser beneficioso para el rendimiento si se analizan un mayor número de archivos pequeños.

source
TOML.ParserError — Type
ParserError

Tipo que se devuelve de tryparse y tryparsefile cuando el análisis falla. Contiene (entre otros) los siguientes campos:

  • pos, la posición en la cadena cuando ocurrió el error
  • table, el resultado que hasta ahora se ha analizado con éxito
  • type, un tipo de error, diferente para diferentes tipos de errores
source