public CustomRW(Fn <A, string> serialize, Fn <string, Option <A> > deserialize, PrefVal.OnDeserializeFailure onDeserializeFailure, ILog log)
{
this.serialize = serialize;
this.deserialize = deserialize;
this.onDeserializeFailure = onDeserializeFailure;
this.log = log;
}
public PrefVal <Option <A> > opt <A>(
string key, Option <A> defaultVal,
ISerializedRW <A> aRW,
bool saveOnEveryWrite = true,
PrefVal.OnDeserializeFailure onDeserializeFailure = PrefVal.OnDeserializeFailure.ReturnDefault,
ILog log = null
) => create(key, defaultVal, PrefValRW.opt(aRW, onDeserializeFailure, log), saveOnEveryWrite);
public PrefVal <C> collection <A, C>(
string key, ISerializedRW <C> rw, C defaultVal,
PrefVal.OnDeserializeFailure onDeserializeFailure =
PrefVal.OnDeserializeFailure.ReturnDefault,
ILog log = null
) where C : ICollection <A> =>
custom(key, defaultVal, rw, onDeserializeFailure, log);
public PrefVal <A> base64 <A>(
string key, A defaultVal,
Fn <A, IEnumerable <byte[]> > serialize,
Fn <byte[][], Option <A> > deserialize,
bool saveOnEveryWrite = true,
PrefVal.OnDeserializeFailure onDeserializeFailure = PrefVal.OnDeserializeFailure.ReturnDefault,
ILog log = null
)
{
const char separator = '|';
return(custom(
key, defaultVal,
a => serialize(a).Select(Convert.ToBase64String).mkString(separator),
base64Str => {
try {
// Split on empty string gives an array with 1 empty string
var parts = base64Str == "" ? new byte[][] {} : base64Str.Split(separator).map(Convert.FromBase64String);
return deserialize(parts);
}
catch (FormatException) {
return Option <A> .None;
}
},
saveOnEveryWrite: saveOnEveryWrite,
onDeserializeFailure: onDeserializeFailure,
log: log
));
}
public PrefVal <A> custom <A>(
string key, A defaultVal,
Fn <A, string> serialize, Fn <string, Option <A> > deserialize,
PrefVal.OnDeserializeFailure onDeserializeFailure = PrefVal.OnDeserializeFailure.ReturnDefault,
ILog log = null
) => create(
key, defaultVal, PrefValRW.custom(serialize, deserialize, onDeserializeFailure, log)
);
public PrefVal <A> custom <A>(
string key, A defaultVal,
ISerializedRW <A> aRW,
PrefVal.OnDeserializeFailure onDeserializeFailure = PrefVal.OnDeserializeFailure.ReturnDefault,
ILog log = null
) => create(
key, defaultVal, PrefValRW.custom(aRW, onDeserializeFailure, log)
);
public PrefVal <ImmutableArray <A> > array <A>(
string key, ISerializedRW <A> rw,
ImmutableArray <A> defaultVal,
PrefVal.OnDeserializeFailure onDeserializeFailure =
PrefVal.OnDeserializeFailure.ReturnDefault,
ILog log = null
) => collection(
key, rw, CollectionBuilderKnownSizeFactory <A> .immutableArray, defaultVal,
onDeserializeFailure, log
);
public PrefVal <ImmutableHashSet <A> > hashSet <A>(
string key, ISerializedRW <A> rw,
ImmutableHashSet <A> defaultVal = null, bool saveOnEveryWrite = true,
PrefVal.OnDeserializeFailure onDeserializeFailure =
PrefVal.OnDeserializeFailure.ReturnDefault,
ILog log = null
) => collection(
key, rw, a => a.ToImmutableHashSet(), defaultVal ?? ImmutableHashSet <A> .Empty,
saveOnEveryWrite, onDeserializeFailure, log
);
public PrefVal <ImmutableArray <A> > array <A>(
string key, ISerializedRW <A> rw,
ImmutableArray <A> defaultVal, bool saveOnEveryWrite = true,
PrefVal.OnDeserializeFailure onDeserializeFailure =
PrefVal.OnDeserializeFailure.ReturnDefault,
ILog log = null
) => collection(
key, rw, a => a, defaultVal, saveOnEveryWrite,
onDeserializeFailure, log
);
public PrefVal <ImmutableHashSet <A> > hashSet <A>(
string key, ISerializedRW <A> rw,
ImmutableHashSet <A> defaultVal = null,
PrefVal.OnDeserializeFailure onDeserializeFailure =
PrefVal.OnDeserializeFailure.ReturnDefault,
ILog log = null
) => collection(
key, rw, CollectionBuilderKnownSizeFactory <A> .immutableHashSet,
defaultVal ?? ImmutableHashSet <A> .Empty,
onDeserializeFailure, log
);
public PrefVal <C> collection <A, C, CB>(
string key,
Fn <A, byte[]> serialize, Fn <byte[], Option <A> > deserialize,
Fn <CB> createCollectionBuilder, Act <CB, A> addToCollection,
Fn <CB, C> builderToCollection,
C defaultVal, bool saveOnEveryWrite = true,
PrefVal.OnDeserializeFailure onDeserializeFailure =
PrefVal.OnDeserializeFailure.ReturnDefault,
PrefVal.OnDeserializeCollectionItemFailure onDeserializeCollectionItemFailure =
PrefVal.OnDeserializeCollectionItemFailure.Ignore,
ILog log = null
) where C : IEnumerable <A>
{
log = log ?? Log.defaultLogger;
return(base64(
key, defaultVal,
c => c.Select(a => serialize(a)),
parts => {
var b = createCollectionBuilder();
foreach (var partData in parts)
{
var deserialized = deserialize(partData);
if (deserialized.isDefined)
{
addToCollection(b, deserialized.get);
}
else
{
if (
onDeserializeCollectionItemFailure ==
PrefVal.OnDeserializeCollectionItemFailure.Ignore
)
{
if (log.isWarn())
{
log.warn(deserializeCollectionItemFailureMsg <A, C>(key, partData, ", ignoring"));
}
}
else
{
throw new SerializationException(
deserializeCollectionItemFailureMsg <A, C>(key, partData)
);
}
}
}
return builderToCollection(b).some();
},
saveOnEveryWrite: saveOnEveryWrite,
onDeserializeFailure: onDeserializeFailure,
log: log
));
}
static PrefVal <ImmutableList <int> > create(
ImmutableList <int> defaultVal,
Deserialize <DeserializeInfo <int> > deserializeFn = null,
PrefVal.OnDeserializeFailure onDeserializeFailure =
PrefVal.OnDeserializeFailure.ReturnDefault
) =>
storage.collection(
key,
SerializedRW.lambda(serialize, deserializeFn ?? SerializedRW.integer.deserialize),
convert, defaultVal,
onDeserializeFailure: onDeserializeFailure,
log: log
);
public PrefVal <ImmutableHashSet <A> > hashSet <A>(
string key,
Fn <A, byte[]> serialize, Fn <byte[], Option <A> > deserialize,
ImmutableHashSet <A> defaultVal = null, bool saveOnEveryWrite = true,
PrefVal.OnDeserializeFailure onDeserializeFailure =
PrefVal.OnDeserializeFailure.ReturnDefault,
PrefVal.OnDeserializeCollectionItemFailure onDeserializeCollectionItemFailure =
PrefVal.OnDeserializeCollectionItemFailure.Ignore,
ILog log = null
) => collection(
key, serialize, deserialize,
ImmutableHashSet.CreateBuilder <A>, (b, a) => b.Add(a), b => b.ToImmutable(),
defaultVal ?? ImmutableHashSet <A> .Empty,
saveOnEveryWrite, onDeserializeFailure, onDeserializeCollectionItemFailure, log
);
public PrefVal <C> collection <A, C>(
string key,
ISerializedRW <A> rw, CollectionBuilderKnownSizeFactory <A, C> factory,
C defaultVal,
PrefVal.OnDeserializeFailure onDeserializeFailure =
PrefVal.OnDeserializeFailure.ReturnDefault,
ILog log = null
) where C : ICollection <A>
{
var collectionRw = SerializedRW.a(
SerializedRW.collectionSerializer <A, C>(rw),
SerializedRW.collectionDeserializer(rw, factory)
);
return(collection <A, C>(
key, collectionRw, defaultVal, onDeserializeFailure, log
));
}
public static IPrefValueRW<A> custom<A>(
ISerializedRW<A> aRW,
PrefVal.OnDeserializeFailure onDeserializeFailure = PrefVal.OnDeserializeFailure.ReturnDefault,
ILog log = null
) => custom(
a => Convert.ToBase64String(aRW.serialize(a).toArray()),
s => {
try {
var bytes = Convert.FromBase64String(s);
return aRW.deserialize(bytes, 0).map(_ => _.value);
}
catch (FormatException) {
return Option<A>.None;
}
},
onDeserializeFailure,
log
);
public PrefVal <A> custom <A>(
string key, A defaultVal, Fn <A, string> serialize, Fn <string, Option <A> > deserialize,
bool saveOnEveryWrite = true,
PrefVal.OnDeserializeFailure onDeserializeFailure = PrefVal.OnDeserializeFailure.ReturnDefault,
ILog log = null
)
{
const string defaultValue = "d", nonDefaultValueDiscriminator = "_";
log = log ?? Log.defaultLogger;
return(new PrefValImpl <A>(
key,
() => {
var serialized = backend.getString(key, defaultValue);
if (serialized == defaultValue)
{
return defaultVal;
}
else
{
var serializedWithoutDiscriminator = serialized.Substring(1);
var opt = deserialize(serializedWithoutDiscriminator);
if (opt.isDefined)
{
return opt.get;
}
if (onDeserializeFailure == PrefVal.OnDeserializeFailure.ReturnDefault)
{
if (log.isWarn())
{
log.warn(deserializeFailureMsg <A>(key, serialized, ", returning default"));
}
return defaultVal;
}
throw new SerializationException(deserializeFailureMsg <A>(key, serialized));
}
},
a => backend.setString(key, $"{nonDefaultValueDiscriminator}{serialize(a)}"),
backend, saveOnEveryWrite: saveOnEveryWrite
));
}
public PrefVal <A> custom <A>(
string key, A defaultVal, Fn <A, byte[]> serialize, Fn <byte[], Option <A> > deserialize,
bool saveOnEveryWrite = true,
PrefVal.OnDeserializeFailure onDeserializeFailure = PrefVal.OnDeserializeFailure.ReturnDefault,
ILog log = null
) => custom(
key, defaultVal,
a => Convert.ToBase64String(serialize(a)),
s => {
try {
var bytes = Convert.FromBase64String(s);
return(deserialize(bytes));
}
catch (FormatException) {
return(Option <A> .None);
}
},
saveOnEveryWrite: saveOnEveryWrite, onDeserializeFailure: onDeserializeFailure, log: log
);
public PrefVal <C> collection <A, C>(
string key,
ISerializedRW <A> rw, Fn <ImmutableArray <A>, C> toCollection,
C defaultVal, bool saveOnEveryWrite = true,
PrefVal.OnDeserializeFailure onDeserializeFailure =
PrefVal.OnDeserializeFailure.ReturnDefault,
ILog log = null
) where C : ICollection <A>
{
var collectionRw = SerializedRW.a(
SerializedRW.collectionSerializer <A, C>(rw),
SerializedRW
.collectionDeserializer(rw)
.map(arr => toCollection(arr).some())
);
return(collection <A, C>(
key, collectionRw, defaultVal, saveOnEveryWrite, onDeserializeFailure, log
));
}
public static IPrefValueRW<A> custom<A>( Fn<A, string> serialize, Fn<string, Option<A>> deserialize, PrefVal.OnDeserializeFailure onDeserializeFailure = PrefVal.OnDeserializeFailure.ReturnDefault, ILog log = null ) => new CustomRW<A>(serialize, deserialize, onDeserializeFailure, log ?? Log.defaultLogger);
public static IPrefValueRW<Option<A>> opt<A>( ISerializedRW<A> baRW, PrefVal.OnDeserializeFailure onDeserializeFailure = PrefVal.OnDeserializeFailure.ReturnDefault, ILog log = null ) => custom(SerializedRW.opt(baRW), onDeserializeFailure, log);
