Savefile is a library to effortlessly serialize rust structs and enums. It uses an efficient binary format. It can serialize to anything implementing the Write trait, and then deserialize from anything implementing the Read trait. This means that savefile can be used to easily save in-memory data structures to disk for persistent storage.
You may ask what savefile brings to the table that serde doesn't already do better. The answer is: Not that much! Savefile is less capable, and not as well tested. It does have versioning support built-in as a first class feature.
Savefile is not yet a very widely used project. However, although there may be bugs, the intention is that the quality should be enough for production.
Cargo.toml:
savefile="0.9"
savefile-derive="0.9"
extern crate savefile;
use savefile::prelude::*;
#[macro_use]
extern crate savefile_derive;
#[derive(Savefile)]
struct Player {
name : String,
strength : u32,
inventory : Vec<String>,
}
fn save_player(player:&Player) {
save_file("save.bin", 0, player).unwrap();
}
fn load_player() -> Player {
load_file("save.bin", 0).unwrap()
}
fn main() {
let player = Player { name: "Steve".to_string(), strength: 42,
inventory: vec!(
"wallet".to_string(),
"car keys".to_string(),
"glasses".to_string())};
save_player(&player);
let reloaded_player = load_player();
assert_eq!(reloaded_player.name,"Steve".to_string());
}Migration note: If you were specifying type parameters explicitly to load_file, or similar functions, you now need to add a ",_". So
let object = load_file::<MyType>("save.bin",0);Must become:
let object = load_file::<MyType,_>("save.bin",0);I hope this does not cause too many problems. The reason is that having functions which open files require '&str' was never a good design, since in principle there could be files whose names are not actually valid utf8. Such files would not be possible to open using Savefile with the old design.
Another change:
It's now possible to opt out of automatically deriving the Introspect-trait, but still automatically derive the serialization traits. It was previously possible to do the opposite, automatically deriving the introspect trait but not the serialization traits. This gap is now filled.
To derive all traits: #[derive(Savefile)]
To derive only Introspect: #[derive(SavefileIntrospectOnly)]
To derive all but Introspect: #[derive(SavefileNoIntrospect)]
Also, the file-handling functions now accept anything implementing AsRef<Path> , which is more ergonomic (it functions just as std lib File::open).
Specifying the savefile_introspect_ignore on a field triggered a bug if that field was not the last field of the datatype. The bug caused a mismatch in the index of the field during introspect, which would make fields not visible through introspection.
- parking_lot from 0.10 -> 0.11
- smallvec 1.4 -> 1.6 (made possible by parking_lot upgrade)
- Make Removed implement Clone, Copy, PartialEq etc. Removed fields shouldn't limit what traits a struct can implement.
- Also make Removed implement Send and Sync. It's a zero-sized type, there are no issues with threading here.
- Add support for std::borrow::Cow. Thanks to github user PonasKovas for this patch!
This also means that SavefileError now (finally) implements the Error trait.
Savefile now supports serializing and deserializing arbitrarily sized arrays, even on stable rust.
Note that 0.8.0 is compatible with Rust 1.51 and later only. If you need support for older rust versions, you should stick with 0.7.x.
Previously, serialization of Arc was not possible. Support is now added, including deduplication of str objects. Note that the deduplication is not actually in the serialized format, just in the result in memory after deduplication. The deduplication does not know how the memory graph looked before saving, it simply makes it so that identical strings are backed by the same memory after loading.
This could cause problems if the code is somehow dependent on the addresses of &str objects. However, this should be rather rare in practice. Just file a bug if you feel that this could be a problem!
PathBuf did not implement Introspect, which had the effect that trying to use derive(Savefile) on anything containing a PathBuf would fail, since the derive macro requires all components to implement all the Savefile traits.
Savefile-derive would previously not work correctly if one tried to use it in a crate where Serde was also used.
This has been fixed.
Also, support for serializing/deserializing PathBuf.
(Not published as of yet)
- Support for arbitrary size arrays, even on stable (thanks to min_const_generics now supported in rust).
Minimum supported rust version for 0.8.x is 1.51.
Savefile is now usable with a stable compiler, not just nightly.
When run on stable, the following features stop working:
-
The whole 'ReprC' subsystem. This means serialization of byte arrays (or other small copy-types) is not as fast as it could be. The slow-down can be several orders of magnitude.
-
Serialization of arbitrary sized arrays. On stable, only arrays of sizes 0-4 are supported.
-
Specialisation of introspection for hashmaps with string keys. This means introspection for hashmaps is not as nice.
The nightly-only features are activated automatically when a nightly compiler is used.
Also, support for Arc<[T]> .
The arrayvec crate has long been a dependency, but the actual ArrayVec type was not supported. We did support ArrayString, but not until 0.7.1 was ArrayVec itself supported.
The dependencies on bitvec, arrayvec and parking_lot where to old versions. They have been updated to:
bit-vec = 0.6
arrayvec = 0.5
parking_lot = 0.10
If you get compilation error saying that SavefileError is not declared, you need this small fix.
This is a breaking change. Hopefully the last one! There is now a more detailed file header, which may make it possible to avoid breaking changes to the base binary framework in the future.
There were two bugs in how encrypted files were encrypted and decrypted. Data corruption could occur.
Also, savefile now supports bzip2-compression. Like the encryption-support, this is just for convenience. It should probably, earnestly, belong out of tree. But I kind of like the idea of "batteries included".
Savefile now includes an introspection feature. See more in the docs.
I just realized that 'ignore' was a very bad name for a custom attribute, since this is now a built-in attribute into the Rust language.
I have prefixed all savefile-attributes with the string "savefile_" .
This breaks existing code, in a rather silent way. The fix is simply to update all usages of savefile-attributes to include prefix 'savefile_' . The samples in the docs are correct.
Also, version 0.3.0 breaks binary compatibility with 0.2.. This is because arrays of generic length are now supported (using Rust nightly's const_generics-feature). Previously short arrays were supported, and were (hackishly) serialized as tuples. Now arrays are truly supported, although very large arrays may cause the stack to be exhausted since the deserialization framework treats arrays as values. This means that any arrays serialized using 0.2. cannot be deserialized using 0.3.*.
Contact me if this is a showstopper. My general feeling, though, is that there are no users of this software except the author.
The savefile docs are available at: https://docs.rs/savefile/0.6.1/savefile/
Features savefile has:
- Fast binary serialization and deserialization
- Support for old versions of the save format
- Completely automatic implementation using "custom derive". You do not have to figure out how your data is to be saved.
Features savefile does not have, and will not have:
- Support for external protocols/data formats. There'll never be json, yaml, xml or any other backends. Savefile uses the savefile format, period.
- Support for serializing graphs. Savefile can serialize your data if it has a tree structure in RAM, without loops.
- Support for serializing boxed traits ("objects"). You can (probably) hack this in by manually implementing the Serialize and Deserialize traits and somehow select concrete types in the deserializer manually.
Savefile is licensed under either of
- Apache License, Version 2.0, (LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0)
- MIT license (LICENSE-MIT or http://opensource.org/licenses/MIT)
at your option.
MIT License text:
Copyright 2018 Anders Musikka
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.