GitHub

TOML

TOML.jl is a Julia standard library for parsing and writing TOML v1.0 files.

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…

Pour analyser un fichier, utilisez TOML.parsefile. Si le fichier contient une erreur de syntaxe, une exception est levée :

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
                 ^
[...]

Il existe d'autres versions des fonctions de parsing (TOML.tryparse et TOML.tryparsefile) qui, au lieu de lancer des exceptions en cas d'erreur de parsing, retournent un TOML.ParserError avec des informations :

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 fonction TOML.print est utilisée pour imprimer (ou sérialiser) des données au format 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]

Les clés peuvent être triées en fonction d'une certaine valeur.

julia> using TOML

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

Pour les structures personnalisées, passez une fonction qui convertit la structure en un type pris en charge.

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})

Analyse la chaîne ou le flux x, et retourne la table résultante (dictionnaire). Lève une ParserError en cas d'échec.

Voir aussi TOML.tryparse.

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

Analyse la chaîne ou le flux x, et retourne la table résultante (dictionnaire). Retourne une ParserError en cas d'échec.

Voir aussi TOML.parse.

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

Analyse le fichier f et retourne la table résultante (dictionnaire). Retourne une ParserError en cas d'échec.

Voir aussi TOML.parsefile.

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

Écrivez data en syntaxe TOML dans le flux io. Si l'argument clé sorted est défini sur true, triez les tables selon la fonction donnée par l'argument clé by. Si l'argument clé inline_tables est donné, il doit s'agir d'un ensemble de tables qui doivent être imprimées "inline".

Les types de données suivants sont pris en charge : AbstractDict, AbstractVector, AbstractString, Integer, AbstractFloat, Bool, Dates.DateTime, Dates.Time, Dates.Date. Notez que les entiers et les flottants doivent être convertibles en Float64 et Int64 respectivement. Pour d'autres types de données, passez la fonction to_toml qui prend les types de données et renvoie une valeur d'un type pris en charge.

source
TOML.Parser — Type
Parser()

Constructeur pour un Parser TOML. Notez que dans la plupart des cas, il n'est pas nécessaire de créer explicitement un Parser, mais on utilise plutôt directement TOML.parsefile ou TOML.parse. L'utilisation d'un parser explicite réutilisera cependant certaines structures de données internes, ce qui peut être bénéfique pour les performances si un plus grand nombre de petits fichiers sont analysés.

source
TOML.ParserError — Type
ParserError

Type qui est retourné par tryparse et tryparsefile lorsque l'analyse échoue. Il contient (entre autres) les champs suivants :

  • pos, la position dans la chaîne lorsque l'erreur s'est produite
  • table, le résultat qui a jusqu'à présent été analysé avec succès
  • type, un type d'erreur, différent pour différents types d'erreurs
source