Newer
Older
using System.Collections.Generic;
using System.Linq;
namespace REST_JSON_API
{
/// <summary>
/// Used to check for approximate equality on number values, e.g. within <see cref="SOMDoc.Equivalent(SOMDoc)"/>
/// </summary>
public class ApproximationComparer : EqualityComparer<object>
{
public static readonly ApproximationComparer Instance = new();
private double precission;
public ApproximationComparer(double precission = Math3d.vectorPrecission)
{
this.precission = precission;
}
public override bool Equals(object x, object y)
{
if (x.Equals(y))
return true;
if (x.GetType() != y.GetType())
return false;
if (x is float fx)
return Math3d.Approximately(fx, (float)y, (float)precission);
return Math3d.IsApproximatelyEqual(vx, (Vector3)y, precission);
return false;
}
public override int GetHashCode(object obj)
{
if (obj is float)
return typeof(float).GetHashCode();
if (obj is Vector3)
return typeof(Vector3).GetHashCode();
return obj.GetHashCode();
}
}
[JsonConverter(typeof(JsonSubtypes), "kind")]
[JsonSubtypes.KnownSubType(typeof(OMS), "OMS")]
[JsonSubtypes.KnownSubType(typeof(OMV), "VAR")]
[JsonSubtypes.KnownSubType(typeof(FUN), "FUN")]
[JsonSubtypes.KnownSubType(typeof(FUNTYPE), "FUNTYPE")]
//[JsonSubtypes.KnownSubType(typeof(OMC<T>), "OMC<" + typeof(T).Name + ">")]
[JsonSubtypes.KnownSubType(typeof(OMLIT<bool>), "OMLIT<Boolean>")]
[JsonSubtypes.KnownSubType(typeof(OMLIT<byte>), "OMLIT<Byte>")]
[JsonSubtypes.KnownSubType(typeof(OMLIT<short>), "OMLIT<Int16>")]
[JsonSubtypes.KnownSubType(typeof(OMLIT<int>), "OMLIT<Int32>")]
[JsonSubtypes.KnownSubType(typeof(OMLIT<long>), "OMLIT<Int64>")]
[JsonSubtypes.KnownSubType(typeof(OMLIT<float>), "OMLIT<Single>")]
[JsonSubtypes.KnownSubType(typeof(OMLIT<float>), "OMLIT<Double>")] // we dont use double
[JsonSubtypes.KnownSubType(typeof(OMLIT<string>), "OMLIT<String>")]
[JsonSubtypes.KnownSubType(typeof(OMLIT<Vector3>), "OMLIT<Vector3>")]
[JsonSubtypes.FallBackSubType(typeof(FallbackWrapper))]
//[JsonSubtypes.KnownSubType(typeof(FallbackWrapper), "SFunction")]
//[JsonSubtypes.KnownSubTypeWithProperty(typeof(FallbackWrapper), "SFunction")]
/// <summary>
/// Implements the Server REST API for Formats/SOMDoc from https://github.com/UniFormal/MMT/blob/devel/src/frameit-mmt/README.md#formats
/// </summary>
abstract public partial class SOMDoc
{
public string kind;
protected SOMDoc() { kind = this.GetType().Name; }
protected internal abstract SOMDoc SOMDocType(SOMDoc[] args, FUN.Param[] bound_params);
=> SOMDocType(new SOMDoc[0], new FUN.Param[0]);
public static SOMDoc SOMDocType(Type type)
{
SOMDoc[] args = type.IsGenericType
? type.GetGenericArguments().Select(t => SOMDocType(t)).ToArray()
: type.HasElementType ? new[] { SOMDocType(type.GetElementType()) }
if (type == typeof(Vector3) // Isomoprhismus
|| TupleExtensions.IsTupleType(type, out _)) // Dictionary does not like Generics
type = typeof(Tuple);
if (type.HasElementType) // pretend its a List
type = typeof(List<>);
if (type.IsGenericType) // Dictionary does not like Assembled Generics
type = type.GetGenericTypeDefinition();
if (FuncExtensions.IsFuncType(type, out _))
return new FUNTYPE(args[..^1], args[^1]);
if (MMTConstants.TYPE_TO_OMS.TryGetValue(type, out string uri))
return args != null
? new OMA(new OMS(uri), args)
: new OMS(uri);
if (type.IsAnonymousType())
return new OMA(
type.GetFields()
.Select(mem => new OML_Member(mem.Name, SOMDocType(mem.FieldType), null))
.ToArray());
throw new NotImplementedException($"For Type {type}");
/// <summary>
/// Attempts to build a @SOMDoc from any object.
/// </summary>
/// <param name="obj">object to parse</param>
/// <param name="force">uses case for Anonymous classes as failsafe</param>
/// <returns></returns>
/// <exception cref="NotSupportedException">iff <c>typeof(<paramref name="obj"/>) == Func</c></exception>
/// <exception cref="NotImplementedException">iff unknown type and <c><paramref name="force"/> == false</c></exception>
public static SOMDoc SOMDocObject(object obj, bool force = false)
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
{
Type type = obj.GetType();
if (type == typeof(Vector3)) // Isomoprhismus
return MakeVector3((Vector3)obj);
if (obj is ITuple tuple) //TupleExtensions.IsTupleType(type, out int tuple_count)
{
SOMDoc[] payload = new SOMDoc[tuple.Length];
for (int i = 0; i < tuple.Length; i++)
payload[i] = SOMDocObject(tuple[i]);
return MakeTupel(payload);
}
if (type.HasElementType) // pretend its a List
type = typeof(List<>);
if (type.IsGenericType) // Dictionary does not like Assembled Generics
type = type.GetGenericTypeDefinition();
if (type == typeof(List<>))
{
List<SOMDoc> payload = new();
foreach (object o in (IEnumerable)obj)
payload.Add(SOMDocObject(o));
return MakeShallowList(payload.ToArray());
}
if (MMTConstants.TYPE_TO_OMS.TryGetValue(type, out string uri))
switch (obj)
{
case bool b: return new OMLIT<bool>(b, uri);
case int i: return new OMLIT<int>(i, uri);
case float f: return new OMLIT<float>(f, uri);
case double d: return new OMLIT<double>(d, uri);
case char c: return new OMLIT<char>(c, uri);
case string s: return new OMLIT<string>(s, uri);
case Fact f: return f.Defines();
default: goto Error;
}
if (FuncExtensions.IsFuncType(type, out _))
throw new NotSupportedException("Cannot reconstruct SOMDoc from Func<>!");
if (force
|| type.IsAnonymousType())
return new OMA(
new OMS(MMTConstants.MakeType),
type.GetFields()
.Select(mem =>
new OML_Member(
mem.Name,
null, //SOMDocType(mem.FieldType),
SOMDocObject(mem.GetValue(obj))
)
).ToArray()
);
Error:
throw new NotImplementedException($"For Type {type}");
}
protected internal abstract Type ToType(Type[] args, (string name, Type type)[] bound_params);
public Type ToType()
=> ToType(new Type[0], new (string name, Type type)[0]);
public static bool Equivalent(SOMDoc sd1, SOMDoc sd2)
=> sd1 != null && sd2 != null
&& sd1.Equivalent(sd2);
public abstract bool Equivalent(SOMDoc sd2);
public LambdaExpression GetLambdaExpression()
=> GetLambdaExpression(new LambdaExpression[0], new LambdaExpression[0], new ParameterExpression[0]);
public LambdaExpression GetLambdaExpression(LambdaExpression[] lambda_applicant, LambdaExpression[] lambda_arguments, ParameterExpression[] bound_params)
=> _GetLambdaExpression(lambda_applicant, lambda_arguments, bound_params);
protected abstract LambdaExpression _GetLambdaExpression(LambdaExpression[] lambda_applicant, LambdaExpression[] lambda_arguments, ParameterExpression[] bound_params);
public abstract override string ToString();
public abstract SOMDoc MapURIs(Dictionary<string, string> old_to_new);
public abstract string[] GetDependentFactIds();
#region MakeMMT_OMS_URItoSOMDoc
MaZiFAU
committed
throw new FormatException("Argument " + nameof(tuple) + "." + nameof(OMA.arguments)
return new Vector3((float)xyz[0].value, (float)xyz[1].value, (float)xyz[2].value);
public static OMA MakeVector3(Vector3 vec)
MaZiFAU
committed
=> MakeTupel(new[] {
new OMLIT<float>(vec.x),
new OMLIT<float>(vec.y),
new OMLIT<float>(vec.z),
MaZiFAU
committed
});
public static OMA MakeTupel(SOMDoc[] args)
=> new(
new OMS(MMTConstants.Tuple),
args
);
public static OMA MakeShallowList(SOMDoc[] args)
=> new(
new OMS(MMTConstants.ListApplicant),
args
);
MaZiFAU
committed
public static OMA MakeDeepList(SOMDoc[] args, SOMDoc SOMDoc_type)
{
SOMDoc[] end_of_list = new SOMDoc[] {
new OMA(
new OMS(MMTConstants.ListEnd),
new[] {
MaZiFAU
committed
SOMDoc_type,
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
}
),
args.Length == 0
? null
: args[^1]
};
if (args.Length == 0)
end_of_list = end_of_list[..^0];
SOMDoc defines = new OMA(
new OMS(MMTConstants.ListLiteral),
end_of_list
);
for (int i = args.Length - 2; i >= 0; i--)
{
defines = new OMA(
new OMS(MMTConstants.ListLiteral),
new[] {
defines,
args[i],
});
}
SOMDoc type = new OMA(
MaZiFAU
committed
new OMS(MMTConstants.ListType),
new[] { SOMDoc_type }
);
return new OMA(type, new[] { defines });
}
#endregion MakeMMT_OMS_URItoSOMDoc
}
public abstract class SOMDocCRTP<T> : SOMDoc where T : SOMDocCRTP<T>
{
protected SOMDocCRTP() : base() { }
public override bool Equivalent(SOMDoc sd2)
=> this.GetType() == sd2.GetType() && (this as T).EquivalentWrapped(sd2 as T);
protected abstract bool EquivalentWrapped(T sd2);
public override SOMDoc MapURIs(Dictionary<string, string> old_to_new)
=> MapURIsWrapped(old_to_new);
protected abstract T MapURIsWrapped(Dictionary<string, string> old_to_new);
}
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
public class FUNTYPE : SOMDocCRTP<FUNTYPE>
{
public new string kind = "FUNTYPE";
public SOMDoc[] @params;
public SOMDoc ret;
[JsonConstructor]
public FUNTYPE(SOMDoc[] @params, SOMDoc ret)
{
this.@params = @params;
this.ret = ret;
}
public override string ToString()
=> "["
+ string.Join(", ", @params.Select(p => p.ToString()))
+ "] => {"
+ ret.ToString()
+ "}";
protected override bool EquivalentWrapped(FUNTYPE sd2)
=> @params.Length == sd2.@params.Length
&& @params.Zip(sd2.@params, (a, b) => a.Equivalent(b))
.All(b => b)
&& ret.Equivalent(sd2.ret);
protected override FUNTYPE MapURIsWrapped(Dictionary<string, string> old_to_new)
=> new(@params.Select(p => p.MapURIs(old_to_new)).ToArray()
, ret.MapURIs(old_to_new));
public override string[] GetDependentFactIds()
=> new string[0];
protected override LambdaExpression _GetLambdaExpression(LambdaExpression[] lambda_applicant, LambdaExpression[] lambda_arguments, ParameterExpression[] bound_params)
{
throw new NotImplementedException();
}
protected internal override SOMDoc SOMDocType(SOMDoc[] args, FUN.Param[] bound_params)
{
throw new NotImplementedException();
}
protected internal override Type ToType(Type[] args, (string name, Type type)[] bound_params)
=> FuncExtensions.CreateFuncType(Enumerable.Append(@params.Select(p => p.ToType()), ret.ToType()).ToArray());
}
public class FUN : SOMDocCRTP<FUN>
{
public new string kind = "FUN";
public Param[] @params;
public SOMDoc body;
[JsonConstructor]
public FUN(Param[] @params, SOMDoc body)
{
this.@params = @params;
this.body = body;
}
public class Param
{
public string name;
[JsonConstructor]
public Param(string name, SOMDoc tp)
{
this.name = name;
public override string ToString()
=> name + "(" + type.ToString() + ")";
}
public override string ToString()
=> "["
+ string.Join(", ", @params.Select(p => p.ToString()))
+ "] => {"
+ body.ToString()
+ "}";
protected override bool EquivalentWrapped(FUN sd2)
=> @params.Length == sd2.@params.Length
&& @params.Zip(sd2.@params, (a, b) => a.name.Equals(b.name)
.All(b => b)
&& body.Equivalent(sd2.body);
protected override FUN MapURIsWrapped(Dictionary<string, string> old_to_new)
=> new(@params.Select(p => new Param(p.name, p.type.MapURIs(old_to_new))).ToArray()
public override string[] GetDependentFactIds()
=> body.GetDependentFactIds();
protected override LambdaExpression _GetLambdaExpression(LambdaExpression[] lambda_applicant, LambdaExpression[] lambda_arguments, ParameterExpression[] bound_params)
ParameterExpression[] local_param =
@params.Select(p => Expression.Parameter(p.type.ToType(), p.name)).ToArray();
LambdaExpression body_lambda =
body.GetLambdaExpression(
new LambdaExpression[0],
new LambdaExpression[0],
bound_params.ShallowCloneAppend(local_param)
);
LambdaExpression ret = Expression.Lambda(body_lambda.Body, local_param);
if (lambda_applicant.Length > 0)
return SOMDocToLambdaExpression._PartialInvoke(ret, lambda_applicant, bound_params);
else
return Expression.Lambda(
ret,
bound_params
);
protected internal override SOMDoc SOMDocType(SOMDoc[] args, Param[] bound_params)
{
Param[] bind_me = bound_params.ShallowCloneAppend(@params);
return new FUNTYPE(
@params.Select(p => p.type).ToArray(),
body.SOMDocType(new SOMDoc[0], bind_me)
);
}
protected internal override Type ToType(Type[] args, (string name, Type type)[] bound_params)
{
(string name, Type)[] bind_me = bound_params
.AppendRange(@params.Select(p => (p.name, p.type.ToType())))
.ToArray();
return SOMDocType().ToType(new Type[0], bind_me);
}
public string name;
[JsonConstructor]
{
this.name = name;
}
protected override bool EquivalentWrapped(OMV sd2)
=> this.name == sd2.name;
protected internal override SOMDoc SOMDocType(SOMDoc[] args, FUN.Param[] bound_params)
{
FUN.Param p = bound_params.FirstOrDefault(param => param.name.Equals(name))
?? throw new FormatException($"Unable to find {nameof(FUN.Param)} for {nameof(OMV)} with name: {name}");
return p.type;
}
protected internal override Type ToType(Type[] args, (string name, Type type)[] bound_params)
{
(string name, Type type) p = bound_params.FirstOrDefault(param => param.name.Equals(name));
if (p == default)
throw new FormatException($"Unable to find {nameof(FUN.Param)} for {nameof(OMV)} with name: {name}");
return p.type;
}
protected override LambdaExpression _GetLambdaExpression(LambdaExpression[] lambda_applicant, LambdaExpression[] lambda_arguments, ParameterExpression[] bound_params)
// in case of ambiguity: latest entry *should* be bounded stronger
ParameterExpression v = bound_params.Reverse().FirstOrDefault(param => param.Name.Equals(name));
if (v == null)
{
Debug.LogErrorFormat("Unable to find {0} for {1} with name: {2}", nameof(FUN.Param), nameof(OMV), name);
return Expression.Lambda(Expression.Empty(), null);
}
else
return Expression.Lambda(v, new[] { v });
}
public override string ToString()
protected override OMV MapURIsWrapped(Dictionary<string, string> old_to_new)
=> (OMV)this.MemberwiseClone();
public override string[] GetDependentFactIds()
=> new string[0];
}
public class OMA : SOMDocCRTP<OMA>
{
public new string kind = "OMA";
public SOMDoc applicant;
public SOMDoc[] arguments;
[JsonConstructor]
public OMA(SOMDoc applicant, SOMDoc[] arguments) : base()
{
this.applicant = applicant;
this.arguments = arguments;
}
protected override bool EquivalentWrapped(OMA sd2)
=> Equivalent(this.applicant, sd2.applicant)
&& this.arguments
.Zip(sd2.arguments, (arg1, arg2) => Equivalent(arg1, arg2))
.All(b => b);
protected override LambdaExpression _GetLambdaExpression(LambdaExpression[] lambda_arguments_paps, LambdaExpression[] lambda_arguments_grands, ParameterExpression[] bound_params)
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
{
if (applicant is OMS OMSMake)
if (OMSMake.uri == MMTConstants.MakeType
|| OMSMake.uri == MMTConstants.MakeTypeType)
{
KeyValuePair<string, LambdaExpression>[] members = arguments
.Select(arg => (OML_Member)arg)
.Select(rec => new KeyValuePair<string, LambdaExpression>(
rec.name,
(rec.defines ?? rec.of_type)
.GetLambdaExpression(new LambdaExpression[0], new LambdaExpression[0], bound_params)))
.ToArray();
return SOMDocToLambdaExpression.MakeType(members, bound_params);
}
return applicant.GetLambdaExpression(
arguments.Select(arg => arg.GetLambdaExpression(new LambdaExpression[0], new LambdaExpression[0], bound_params)).ToArray(),
lambda_arguments_paps,
bound_params
);
}
protected internal override SOMDoc SOMDocType(SOMDoc[] args, FUN.Param[] bound_params)
{
if (applicant is OMS OMSMake
&& OMSMake.uri == MMTConstants.GetField)
{
return (arguments[0] as OMA).arguments
.Select(arg => (OML_Member)arg) //RECTYPE?
.First(rec => rec.name == ((OML_Member)arguments[1]).name)
.defines.SOMDocType(new SOMDoc[0], bound_params);
}
return applicant.SOMDocType(
arguments.Select(a => a.SOMDocType(new SOMDoc[0], bound_params)).ToArray(),
bound_params
);
}
protected internal override Type ToType(Type[] args, (string name, Type type)[] bound_params)
{
if (applicant is OMS OMSMake)
if (OMSMake.uri == MMTConstants.MakeType
|| OMSMake.uri == MMTConstants.MakeTypeType)
{
KeyValuePair<string, Type>[] members = arguments
.Select(arg => (OML_Member)arg)
.Select(rec => new KeyValuePair<string, Type>(
rec.name,
rec.of_type.ToType(new Type[0], bound_params)))
.ToArray();
return TupleFactory.Create(members).TupleType;
}
else
if (OMSMake.uri == MMTConstants.GetField)
{
return args[0].GetMember(((OML_Member)arguments[1]).name).First().ReflectedType;
}
return applicant.ToType(
arguments.Select(arg => arg.ToType(new Type[0], bound_params)).ToArray(),
bound_params
);
}
public override string ToString()
=> applicant.ToString() + "(" + string.Join(", ", arguments.Select(a => a.ToString())) + ")";
protected override OMA MapURIsWrapped(Dictionary<string, string> old_to_new)
=> new OMA(
applicant.MapURIs(old_to_new),
arguments.Select(arg => arg.MapURIs(old_to_new)).ToArray()
);
public override string[] GetDependentFactIds()
=> applicant.GetDependentFactIds()
.AppendRange(arguments.SelectMany(arg => arg.GetDependentFactIds()))
.ToArray();
}
public class OMS : SOMDocCRTP<OMS>
{
public new string kind = "OMS";
public string uri;
[JsonConstructor]
public OMS(string uri) : base()
{
this.uri = uri;
}
protected override bool EquivalentWrapped(OMS sd2)
{
bool
b1 = FactRecorder.AllFacts.TryGetValue(uri, out Fact f1),
b2 = FactRecorder.AllFacts.TryGetValue(sd2.uri, out Fact f2);
return (b1 == b2 && uri == sd2.uri)
|| (b1 && b2 && f1.Equivalent(f2));
}
protected override LambdaExpression _GetLambdaExpression(LambdaExpression[] lambda_arguments_paps, LambdaExpression[] lambda_arguments_grands, ParameterExpression[] bound_params)
=> SOMDocToLambdaExpression.MakeLambdaExpression(uri, lambda_arguments_paps, lambda_arguments_grands, bound_params);
public override string ToString()
=> uri;
protected override OMS MapURIsWrapped(Dictionary<string, string> old_to_new)
{
if (!old_to_new.TryGetValue(uri, out string new_uri))
new_uri = uri;
return new OMS(new_uri);
}
public override string[] GetDependentFactIds()
=> FactRecorder.AllFacts.ContainsKey(uri)
? new string[] { uri }
: new string[0];
protected internal override Type ToType(Type[] args, (string name, Type type)[] bound_params)
return found.GetMMTType().ToType(args, bound_params);
if (MMTConstants.HeterogenApplication_TO_TypeOF.TryGetValue(uri, out string s_type))
{
Type type = MMTConstants.OMS_TO_TYPE[s_type];
if (type.Equals(typeof(Tuple)))
{ // authors note: Not a fan, but has to be done somewhwere...
MaZiFAU
committed
if (args.Length == 3
&& args.All(t => t == typeof(float)))
return typeof(Vector3);
type = TupleExtensions.GetGenericTupleType(args.Length);
}
else
if (type.Equals(typeof(Func<>)))
return FuncExtensions.CreateFuncType(args);
MaZiFAU
committed
return type
.MakeGenericType(args);
}
if (MMTConstants.HomogenApplication_TO_TypeOF.TryGetValue(uri, out s_type))
return MMTConstants.OMS_TO_TYPE[s_type]
.MakeGenericType(args[0]);
if (MMTConstants.URI_TO_TypeOF.TryGetValue(uri, out s_type))
return MMTConstants.OMS_TO_TYPE[s_type];
if (MMTConstants.OMS_TO_TYPE.TryGetValue(uri, out Type t_type))
return t_type;
throw new NotImplementedException();
}
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
protected internal override SOMDoc SOMDocType(SOMDoc[] args, FUN.Param[] bound_params)
{
string _uri = uri;
bool use_uri;
if (use_uri = MMTConstants.OMS_TO_TYPE.TryGetValue(_uri, out Type tmp_type))
_uri = MMTConstants.TYPE_TO_OMS[tmp_type];
if (FactRecorder.AllFacts.TryGetValue(_uri, out Fact found))
return new OMS(MMTConstants.TYPE_TO_OMS[found.GetType()]);
if (MMTConstants.HeterogenApplication_TO_TypeOF.TryGetValue(_uri, out string type))
return new OMA(
new OMS(type),
args
);
if (MMTConstants.HomogenApplication_TO_TypeOF.TryGetValue(_uri, out type))
return new OMA(
new OMS(type),
new[] { args[0] }
);
if (MMTConstants.URI_TO_TypeOF.TryGetValue(_uri, out type))
return new OMS(type);
if (use_uri)
return SOMDocType(tmp_type);
//return new OMS(_uri);
throw new NotImplementedException(uri);
}
protected internal override SOMDoc SOMDocType(SOMDoc[] args, FUN.Param[] bound_params)
=> throw new NotSupportedException();
protected override RAW MapURIsWrapped(Dictionary<string, string> old_to_new)
{
string copy = xml;
foreach (KeyValuePair<string, string> KeyVal in old_to_new)
copy = copy.Replace(KeyVal.Key, KeyVal.Value);
public override string ToString()
protected override bool EquivalentWrapped(RAW sd2)
=> throw new NotImplementedException(); //xml == sd2.xml; // only exact
protected override LambdaExpression _GetLambdaExpression(LambdaExpression[] lambda_applicant, LambdaExpression[] lambda_arguments, ParameterExpression[] bound_params)
protected internal override Type ToType(Type[] args, (string name, Type type)[] bound_params)
// tp == null && df == null: member access
// tp != null : member/type declaration
// df != null : member value
public class OML_Member : SOMDocCRTP<OML_Member>
public new string kind = "OML";
[JsonProperty("name")]
public string name;
[JsonProperty("tp")]
public SOMDoc of_type;
this.name = name;
this.of_type = of_type;
this.defines = defines;
public override string[] GetDependentFactIds()
=> defines?.GetDependentFactIds() ?? new string[0];
public override string ToString()
{
string tp = of_type == null ? string.Empty : $": {of_type}";
string df = defines == null ? string.Empty : $" = {{{defines}}}";
return $".{name}" + tp + df;
}
protected override bool EquivalentWrapped(OML_Member sd2)
=> name == sd2.name
&& ((of_type == null && sd2.of_type == null) || of_type.Equivalent(sd2.of_type))
&& ((defines == null && sd2.defines == null) || defines.Equivalent(sd2.defines));
protected override OML_Member MapURIsWrapped(Dictionary<string, string> old_to_new)
=> new(name, of_type?.MapURIs(old_to_new), defines?.MapURIs(old_to_new));
protected override LambdaExpression _GetLambdaExpression(LambdaExpression[] lambda_applicant, LambdaExpression[] lambda_arguments, ParameterExpression[] bound_params)
=> defines == null && of_type == null
? Expression.Lambda(Expression.Constant(name, typeof(string))) // PropertyInfo? => would need info about sister element in OMA.arguments
: throw new NotSupportedException(); //=> new KeyValuePair<string, Expression>(name, value.GetLambdaExpression(lambda_applicant, lambda_arguments, bound_params))
protected internal override SOMDoc SOMDocType(SOMDoc[] args, FUN.Param[] bound_params)
=> new OML_Member(
name,
of_type
?? defines?.SOMDocType(args, bound_params)
?? throw new NotSupportedException(), // would need info about sister element in OMA.arguments
null
);
protected internal override Type ToType(Type[] args, (string name, Type type)[] bound_params)
=> defines?.ToType(args, bound_params)
//?? of_type?.ToType(args, bound_params) //is Member Declaration not Member Type
?? throw new NotSupportedException(); // would need info about sister element in OMA.arguments
this.value = value;
this.type = type ?? MMTConstants.TYPE_TO_OMS[value.GetType()];
protected internal override SOMDoc SOMDocType(SOMDoc[] args, FUN.Param[] bound_params)
protected override bool EquivalentWrapped(OMLIT<T> sd2)
=> ApproximationComparer.Instance.Equals(value, sd2);
protected override LambdaExpression _GetLambdaExpression(LambdaExpression[] lambda_applicant, LambdaExpression[] lambda_arguments, ParameterExpression[] bound_params)
protected override OMLIT<T> MapURIsWrapped(Dictionary<string, string> old_to_new)
=> (OMLIT<T>)this.MemberwiseClone();
protected internal override Type ToType(Type[] args, (string name, Type type)[] bound_params)
public class OMNONE : SOMDocCRTP<OMNONE>
{
public static OMNONE Instance { get; } = new OMNONE();
public override string[] GetDependentFactIds() => new string[0];
public override string ToString() => "null";
protected override bool EquivalentWrapped(OMNONE sd2) => true;
protected override OMNONE MapURIsWrapped(Dictionary<string, string> old_to_new) => Instance;
protected override LambdaExpression _GetLambdaExpression(LambdaExpression[] lambda_applicant, LambdaExpression[] lambda_arguments, ParameterExpression[] bound_params)
=> throw new NotSupportedException("Not possible for OMNONE");
protected internal override SOMDoc SOMDocType(SOMDoc[] args, FUN.Param[] bound_params)
=> throw new NotSupportedException("Not possible for OMNONE");
protected internal override Type ToType(Type[] args, (string name, Type type)[] bound_params)
=> throw new NotSupportedException("Not possible for OMNONE");
}
// temporary fix if Serialzation is broken
public class FallbackWrapper : SOMDocCRTP<FallbackWrapper>
MaZiFAU
committed
{
public new string kind = "Wrapper";
MaZiFAU
committed
[JsonConstructor]
public FallbackWrapper(SOMDoc Wrapper)
MaZiFAU
committed
{
MaZiFAU
committed
}
public override string ToString()
MaZiFAU
committed
protected override bool EquivalentWrapped(FallbackWrapper sd2)
MaZiFAU
committed
protected override FallbackWrapper MapURIsWrapped(Dictionary<string, string> old_to_new)
=> new(Wrapper.MapURIs(old_to_new));
MaZiFAU
committed
protected override LambdaExpression _GetLambdaExpression(LambdaExpression[] lambda_applicant, LambdaExpression[] lambda_arguments, ParameterExpression[] bound_params)
=> Wrapper.GetLambdaExpression(lambda_applicant, lambda_arguments, bound_params);
MaZiFAU
committed
protected internal override SOMDoc SOMDocType(SOMDoc[] args, FUN.Param[] bound_params)
=> Wrapper.SOMDocType(args, bound_params);
MaZiFAU
committed
protected internal override Type ToType(Type[] args, (string name, Type type)[] bound_params)
=> Wrapper.ToType(args, bound_params);
public override string[] GetDependentFactIds()
MaZiFAU
committed
}