module ocda.load; /+ ↓ what a path is, and loading it. . One place that decides, so that every reader and every writer accepts the same inputs and a new input type is added once. This mirrors spine's own ocda/abstraction/load.d, which names the sources it can enter the pipeline from and tells them apart by suffix. . Deliberately *not* here: .sst and .ssm markup. Reading markup means implementing the parser, which is spine's work and a far larger thing than a reader or a sample writer needs. This library reads abstractions. +/ import std.algorithm : endsWith; import ocda.model; import ocda.load_ssp; import ocda.load_db; enum Source { ssp, // .ssp, the abstraction as text ocda_db, // .ocda.db, the abstraction as sqlite unknown, } Source sourceOf(string path) { if (path.endsWith(".ocda.db")) { return Source.ocda_db; } if (path.endsWith(".ssp")) { return Source.ssp; } if (path.endsWith(".db")) { return Source.ocda_db; } return Source.unknown; } string sourceName(Source s) { final switch (s) { case Source.ssp: return ".ssp (the abstraction as text)"; case Source.ocda_db: return ".ocda.db (the abstraction as sqlite)"; case Source.unknown: return "not an abstraction this library reads"; } } class OcdaLoadError : Exception { this(string msg) { super(msg); } } /+ ↓ load whatever the path is into the model. lang applies only to a .ocda.db, which holds every language of its document; a .ssp is one language and the argument is ignored. +/ OcdaDocument load(string path, string lang = "", bool any_version = false) { final switch (sourceOf(path)) { case Source.ssp: return parseSspFile(path); case Source.ocda_db: return loadDbFile(path, lang, any_version); case Source.unknown: throw new OcdaLoadError(path ~ ": " ~ sourceName(Source.unknown) ~ " (expected .ssp or .ocda.db)"); } }