fn fmt(&self, f: &mut Formatter) {
match self {
State::Loaded(Loaded{ meta, size, hash }) => {
- let BundleMeta { title } = meta;
+ let BundleMeta { title, mformat:_ } = meta;
write!(f, "Loaded {:10} {} {:?}", size, hash, title)?;
}
other => write!(f, "{:?}", other)?,
}
let bundles = self.iter().filter_map(|(&id, state)| {
if_let!{ State::Loaded(Loaded { meta,.. }) = state; else return None; }
- let BundleMeta { title } = meta;
+ let BundleMeta { title, mformat:_ } = meta;
let title = Html::from_txt(title);
let token = id.token(ig);
let url = hformat!("/_/bundle/{}/{}?{}", &*ig.name, &id, &token);
Ok::<_,LE>(meta)
}, ||{
BundleMeta {
- title: "[bundle metadata could not be reloaded]".to_owned()
+ title: "[bundle metadata could not be reloaded]".to_owned(),
+ mformat: materials_format::Version::CURRENT, // dummy value
}
})?;
svg_dir: &'l String,
need_svgs: Vec<SvgNoted>,
id: &'l Id,
+ mformat: materials_format::Version,
}
impl shapelib::LibrarySource for LibraryInBundle<'_> {
self.need_svgs.push(SvgNoted { item, src_name });
}
fn bundle(&self) -> Option<bundles::Id> { Some(*self.id) }
+
+ #[throws(materials_format::VersionError)]
+ fn default_materials_format(&self) -> materials_format::Version {
+ self.mformat
+ }
}
for LibScanned { libname, dir_inzip, inzip } in libs {
svg_dir: &svg_dir,
need_svgs: Vec::new(),
id: &id,
+ mformat: meta.mformat,
};
let contents = shapelib::load_catalogue(&libname, &mut src)
.map_err(|e| LE::badlib(&libname, &e))?;
#[error("{0}")] BadSubstitution(#[from] SubstError),
#[error("{0}")] UnsupportedColourSpec(#[from] UnsupportedColourSpec),
#[error("bad item name (invalid characters) in {0:?}")] BadItemName(String),
+ #[error("{0:?}")] MaterialsFormatVersionError(#[from] MFVE),
}
#[derive(Error,Copy,Clone,Debug)]
fn note_svg(&mut self, _basename: &GoodItemName,
_src_name: Result<&str, &SubstError>) { }
fn bundle(&self) -> Option<bundles::Id>;
+
+ fn default_materials_format(&self)
+ -> Result<materials_format::Version, MFVE>;
}
struct BuiltinLibrary<'l> {
fn catalogue_data(&self) -> &str { self.catalogue_data }
fn svg_dir(&self) -> String { self.dirname.to_string() }
fn bundle(&self) -> Option<bundles::Id> { None }
+
+ #[throws(materials_format::VersionError)]
+ fn default_materials_format(&self) -> materials_format::Version {
+ materials_format::Version::CURRENT
+ //throw!(MFVE::Other("builtin libraries must have explicit version now!"));
+ }
}
#[throws(LibraryLoadError)]
let toplevel: toml::Value = src.catalogue_data().parse()?;
let toplevel = toplevel
.as_table().ok_or_else(|| LLE::ExpectedTable(format!("toplevel")))?;
+ let mformat = match toplevel.get("format") {
+ None => src.default_materials_format()?,
+ Some(v) => {
+ let v = v.as_integer().ok_or_else(|| MFVE::Other("not an integer"))?;
+ materials_format::Version::try_from_integer(v)?
+ },
+ };
+ let _: materials_format::Version = mformat;
+
let mut l = Catalogue {
bundle: src.bundle(),
libname: libname.to_string(),
use crate::accounts::AccountName;
use crate::error::UnsupportedColourSpec;
use crate::gamestate::PieceSpec;
+use crate::materials_format;
use crate::prelude::default;
use crate::utils::SVGSizeError;
#[derive(Debug,Clone,Serialize,Deserialize)]
pub struct BundleMeta {
pub title: String,
+ #[serde(default, rename="format")]
+ pub mformat: materials_format::Version,
}
//---------- Table TOML file ----------