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 AndRW8(
ISerializedRW <A1> a1Rw, ISerializedRW <A2> a2Rw, ISerializedRW <A3> a3Rw, ISerializedRW <A4> a4Rw,
ISerializedRW <A5> a5Rw, ISerializedRW <A6> a6Rw, ISerializedRW <A7> a7Rw, ISerializedRW <A8> a8Rw,
Func <A1, A2, A3, A4, A5, A6, A7, A8, B> mapper, Func <B, A1> a1, Func <B, A2> a2, Func <B, A3> a3, Func <B, A4> a4,
Func <B, A5> a5, Func <B, A6> a6, Func <B, A7> a7, Func <B, A8> a8
)
{
a1RW = a1Rw;
a2RW = a2Rw;
a3RW = a3Rw;
a4RW = a4Rw;
a5RW = a5Rw;
a6RW = a6Rw;
a7RW = a7Rw;
a8RW = a8Rw;
this.mapper = mapper;
getA1 = a1;
getA2 = a2;
getA3 = a3;
getA4 = a4;
getA5 = a5;
getA6 = a6;
getA7 = a7;
getA8 = a8;
}
public static ICachedBlob <A> a <A>(
ISerializedRW <A> rw, PathStr path, A defaultValue,
ILog log = null, Log.Level onDeserializeFailureLogLevel = Log.Level.ERROR
)
{
log = log ?? Log.d;
return(new FileCachedBlob(path).bimap(BiMapper.a(
(byte[] bytes) => {
var deserializedOpt = rw.deserialize(bytes, 0);
if (deserializedOpt.isNone)
{
if (log.willLog(onDeserializeFailureLogLevel))
{
log.log(
onDeserializeFailureLogLevel,
$"Can't deserialize {path}, deleting and returning default value."
);
}
clear(path).getOrLog($"Couldn't clear file: '{path}'", log: log);
return defaultValue;
}
return deserializedOpt.__unsafeGetValue.value;
},
a => rw.serialize(a).toArray()
)));
}
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 static ISerializedRW <B> mapTry <A, B>(
this ISerializedRW <A> aRW,
Fn <A, B> deserializeConversion,
Fn <B, A> serializeConversion
) => new MappedRW <A, B>(aRW, serializeConversion, a => {
try { return(deserializeConversion(a).some()); }
catch (Exception) { return(Option <B> .None); }
});
public static ISerializedRW <B> mapNoFail <A, B>(
this ISerializedRW <A> aRW,
Func <A, B> deserializeConversion,
Func <B, A> serializeConversion
) => aRW.map(
a => Either <string, B> .Right(deserializeConversion(a)),
serializeConversion
);
public MappedRW(
ISerializedRW <A> aRw, Fn <B, A> serializeConversion,
Fn <A, Option <B> > deserializeConversion
)
{
aRW = aRw;
this.serializeConversion = serializeConversion;
this.deserializeConversion = deserializeConversion;
}
public MappedRW(
ISerializedRW <A> aRw, Func <B, A> serializeConversion,
Func <A, Either <string, B> > deserializeConversion
)
{
aRW = aRw;
this.serializeConversion = serializeConversion;
this.deserializeConversion = deserializeConversion;
}
public AndRW2(
ISerializedRW <A1> a1Rw, ISerializedRW <A2> a2Rw, Func <A1, A2, B> mapper, Func <B, A1> a1, Func <B, A2> a2
)
{
a1RW = a1Rw;
a2RW = a2Rw;
this.mapper = mapper;
getA1 = a1;
getA2 = a2;
}
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,
PrefVal.OnDeserializeFailure onDeserializeFailure =
PrefVal.OnDeserializeFailure.ReturnDefault,
ILog log = null
) => collection(
key, rw, CollectionBuilderKnownSizeFactory <A> .immutableArray, defaultVal,
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 AndRW3(
ISerializedRW <A1> a1Rw, ISerializedRW <A2> a2Rw, ISerializedRW <A3> a3Rw, Func <A1, A2, A3, B> mapper,
Func <B, A1> a1, Func <B, A2> a2, Func <B, A3> a3
)
{
a1RW = a1Rw;
a2RW = a2Rw;
a3RW = a3Rw;
this.mapper = mapper;
getA1 = a1;
getA2 = a2;
getA3 = a3;
}
public AndRW4(
ISerializedRW <A1> a1Rw, ISerializedRW <A2> a2Rw, ISerializedRW <A3> a3Rw, ISerializedRW <A4> a4Rw,
Func <A1, A2, A3, A4, B> mapper, Func <B, A1> a1, Func <B, A2> a2, Func <B, A3> a3, Func <B, A4> a4
)
{
a1RW = a1Rw;
a2RW = a2Rw;
a3RW = a3Rw;
a4RW = a4Rw;
this.mapper = mapper;
getA1 = a1;
getA2 = a2;
getA3 = a3;
getA4 = a4;
}
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 <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 AndRW6(
ISerializedRW <A1> a1Rw, ISerializedRW <A2> a2Rw, ISerializedRW <A3> a3Rw, ISerializedRW <A4> a4Rw,
ISerializedRW <A5> a5Rw, ISerializedRW <A6> a6Rw, Func <A1, A2, A3, A4, A5, A6, B> mapper, Func <B, A1> a1,
Func <B, A2> a2, Func <B, A3> a3, Func <B, A4> a4, Func <B, A5> a5, Func <B, A6> a6
)
{
a1RW = a1Rw;
a2RW = a2Rw;
a3RW = a3Rw;
a4RW = a4Rw;
a5RW = a5Rw;
a6RW = a6Rw;
this.mapper = mapper;
getA1 = a1;
getA2 = a2;
getA3 = a3;
getA4 = a4;
getA5 = a5;
getA6 = a6;
}
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 ISerializedRW <A[]> array <A>(
ISerializedRW <A> rw
) => a(
collectionSerializer <A, A[]>(rw),
collectionDeserializer(rw, CollectionBuilderKnownSizeFactory <A> .array)
);
public static ISerializedRW <ImmutableHashSet <A> > immutableHashSet <A>(
ISerializedRW <A> rw
) => a(
collectionSerializer <A, ImmutableHashSet <A> >(rw),
collectionDeserializer(rw, CollectionBuilderKnownSizeFactory <A> .immutableHashSet)
);
public static ISerializedRW <Either <A, B> > either <A, B>(ISerializedRW <A> aRW, ISerializedRW <B> bRW) => new EitherRW <A, B>(aRW, bRW);
public static ISerializedRW <Option <A> > opt <A>(ISerializedRW <A> rw) => new OptRW <A>(rw);
public static ISerializedRW <B> and <A1, A2, A3, A4, B>(
this ISerializedRW <A1> a1RW, ISerializedRW <A2> a2RW, ISerializedRW <A3> a3RW,
ISerializedRW <A4> a4RW,
Fn <A1, A2, A3, A4, B> mapper, Fn <B, A1> getA1, Fn <B, A2> getA2, Fn <B, A3> getA3, Fn <B, A4> getA4
) => new AndRW4 <A1, A2, A3, A4, B>(a1RW, a2RW, a3RW, a4RW, mapper, getA1, getA2, getA3, getA4);
public static ISerializedRW <B> and <A1, A2, B>(
this ISerializedRW <A1> a1RW, ISerializedRW <A2> a2RW,
Fn <A1, A2, B> mapper, Fn <B, A1> getA1, Fn <B, A2> getA2
) => new AndRW2 <A1, A2, B>(a1RW, a2RW, mapper, getA1, getA2);
public static ISerializedRW <Tpl <A, B> > tpl <A, B>(
this ISerializedRW <A> aRW, ISerializedRW <B> bRW
) => and(aRW, bRW, F.t, t => t._1, t => t._2);
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);
public static ISerializedRW <B> map <A, B>(
this ISerializedRW <A> aRW,
Fn <A, Option <B> > deserializeConversion,
Fn <B, A> serializeConversion
) => new MappedRW <A, B>(aRW, serializeConversion, deserializeConversion);
public static ISerializedRW <OneOf <A, B, C> > oneOf <A, B, C>(
ISerializedRW <A> aRW, ISerializedRW <B> bRW, ISerializedRW <C> cRW
) => new OneOfRW <A, B, C>(aRW, bRW, cRW);
