protected internal override Expression VisitProjection(ProjectionExpression proj)
{
using (HeavyProfiler.LogNoStackTrace(nameof(VisitProjection), () => proj.Type.TypeName()))
{
GetColumnCollector(proj.Select.KnownAliases).Visit(proj.Projector);
SelectExpression source = (SelectExpression)this.Visit(proj.Select);
Expression projector = this.Visit(proj.Projector);
CurrentScope.RemoveAll(kvp =>
{
if (source.KnownAliases.Contains(kvp.Key.Alias))
{
if (kvp.Value == null)
{
throw new InvalidOperationException();
}
return(true);
}
return(false);
});
if (source != proj.Select || projector != proj.Projector)
{
return(new ProjectionExpression(source, projector, proj.UniqueFunction, proj.Type));
}
return(proj);
}
}
public static string WikiParse(this WikiSettings settings, string content)
{
using (HeavyProfiler.Log("Wiki"))
using (var t = HeavyProfiler.LogNoStackTrace("SaveCodeRegions"))
{
string result = content;
result = SaveCodeRegions(result, out Dictionary <string, string> codeRegions);
if (settings.EncodeHtml)
{
t.Switch("HtmlEncode");
//1: Replace token delimiters which are different from their encoded string so that they are not encoded
result = Regex.Replace(result, "'{2,}", m => "####" + m.Length + "####");
//2: Encode all text
result = HttpUtility.HtmlEncode(result);
//3: Replace encrypted tokens to original tokens
result = Regex.Replace(result, "####(?<count>\\d+)####", m => new string('\'', int.Parse(m.Groups["count"].Value)));
}
t.Switch("ProcessTokens");
result = ProcessTokens(result, settings);
t.Switch("ProcessFormat");
result = ProcessFormat(result, settings);
t.Switch("WriteCodeRegions");
result = WriteCodeRegions(result, codeRegions, settings);
return(result.Trim());
}
}
public Dictionary <string, string> IntegrityCheck()
{
using (var log = HeavyProfiler.LogNoStackTrace("IntegrityCheck"))
{
var validators = Validator.GetPropertyValidators(GetType());
Dictionary <string, string> result = null;
foreach (var pv in validators.Values)
{
var error = pv.PropertyCheck(this);
if (error != null)
{
if (result == null)
{
result = new Dictionary <string, string>();
}
result.Add(pv.PropertyInfo.Name, error);
}
}
return(result);
}
}
public List <PredictDictionary> PredictMultiple(PredictorPredictContext ctx, List <PredictDictionary> inputs)
{
using (HeavyProfiler.LogNoStackTrace("PredictMultiple"))
{
var nnSettings = (NeuralNetworkSettingsEntity)ctx.Predictor.AlgorithmSettings;
lock (lockKey) //https://docs.microsoft.com/en-us/cognitive-toolkit/cntk-library-evaluation-on-windows#evaluation-of-multiple-requests-in-parallel
{
Function calculatedOutputs = (Function)ctx.Model !;
var device = GetDevice(nnSettings);
Value inputValue = GetValueForPredict(ctx, inputs, device);
var inputVar = calculatedOutputs.Inputs.SingleEx(i => i.Name == "input");
var inputDic = new Dictionary <Variable, Value> {
{ inputVar, inputValue }
};
var outputDic = new Dictionary <Variable, Value> {
{ calculatedOutputs, null ! }
};
calculatedOutputs.Evaluate(inputDic, outputDic, device);
Value output = outputDic[calculatedOutputs];
IList <IList <float> > values = output.GetDenseData <float>(calculatedOutputs);
var result = values.Select((val, i) => GetPredictionDictionary(val.ToArray(), ctx, inputs[i].Options !)).ToList();
return(result);
}
}
}
public AttributeCollection FieldAttributes(PropertyRoute propertyRoute)
{
using (HeavyProfiler.LogNoStackTrace("FieldAttributes"))
{
return(FieldAttributesCache.GetOrAdd(propertyRoute, pr =>
{
switch (propertyRoute.PropertyRouteType)
{
case PropertyRouteType.FieldOrProperty:
if (propertyRoute.FieldInfo == null)
{
return null;
}
return CreateFieldAttributeCollection(propertyRoute);
case PropertyRouteType.MListItems:
if (propertyRoute.Parent.FieldInfo == null)
{
return null;
}
return CreateFieldAttributeCollection(propertyRoute.Parent);
default:
throw new InvalidOperationException("Route of type {0} not supported for this method".FormatWith(propertyRoute.PropertyRouteType));
}
}));
}
}
public override T GetValue(MappingContext <T> ctx)
{
using (HeavyProfiler.LogNoStackTrace("GetValue", () => "AutoEntityMapping<{0}>".FormatWith(typeof(T).TypeName())))
{
if (ctx.Empty())
{
return(ctx.None());
}
Type entityType;
entityType = GetRuntimeType(ctx);
if (entityType == null)
{
return((T)(object)null);
}
if (typeof(T) == entityType || typeof(T).IsEmbeddedEntity())
{
return(GetRuntimeValue <T>(ctx, ctx.PropertyRoute));
}
return(miGetRuntimeValue.GetInvoker(entityType)(this, ctx, PropertyRoute.Root(entityType)));
}
}
public override MList <S> GetValue(MappingContext <MList <S> > ctx)
{
using (HeavyProfiler.LogNoStackTrace("GetValue", () => "MListCorrelatedMapping<{0}>".FormatWith(typeof(S).TypeName())))
{
MList <S> list = ctx.Value;
int i = 0;
foreach (MappingContext <S> itemCtx in GenerateItemContexts(ctx).OrderBy(mc => mc.Prefix.Substring(mc.Prefix.LastIndexOf("_") + 1).ToInt().Value))
{
Debug.Assert(!itemCtx.Empty());
itemCtx.Value = list[i];
itemCtx.Value = ElementMapping(itemCtx);
ctx.AddChild(itemCtx);
if (!itemCtx.SupressChange && !object.Equals(list[i], itemCtx.Value))
{
Signum.Web.Mapping.AssertCanChange(ctx.PropertyRoute);
}
if (!list[i].Equals(itemCtx.Value))
{
list[i] = itemCtx.Value;
}
i++;
}
return(list);
}
}
public override T GetValue(MappingContext <T> ctx)
{
using (HeavyProfiler.LogNoStackTrace("GetValue", () => "EntityMapping<{0}>".FormatWith(typeof(T).TypeName())))
{
if (ctx.Empty())
{
return(ctx.None());
}
var val = GetEntity(ctx);
if (val == ctx.Value)
{
ctx.SupressChange = true;
}
else
{
ctx.Value = val;
}
SetValueProperties(ctx);
return(val);
}
}
public PropertyRoute Add(MemberInfo member)
{
using (HeavyProfiler.LogNoStackTrace("PR.Add", () => member.Name))
{
if (member is MethodInfo && ((MethodInfo)member).IsInstantiationOf(MixinDeclarations.miMixin))
{
member = ((MethodInfo)member).GetGenericArguments()[0];
}
if (this.Type.IsIEntity() && PropertyRouteType != PropertyRouteType.Root)
{
Implementations imp = GetImplementations();
Type?only;
if (imp.IsByAll || (only = imp.Types.Only()) == null)
{
throw new InvalidOperationException("Attempt to make a PropertyRoute on a {0}. Cast first".FormatWith(imp));
}
return(new PropertyRoute(Root(only), member));
}
return(new PropertyRoute(this, member));
}
}
public override object?ReadJson(JsonReader reader, Type objectType, object?existingValue, JsonSerializer serializer)
{
using (HeavyProfiler.LogNoStackTrace("ReadJson", () => objectType.Name))
{
if (reader.TokenType == JsonToken.Null)
{
return(null);
}
using (EntityCache ec = new EntityCache())
{
reader.Assert(JsonToken.StartObject);
ModifiableEntity mod = GetEntity(reader, objectType, existingValue, out bool markedAsModified);
var pr = GetCurrentPropertyRoute(mod);
var dic = PropertyConverter.GetPropertyConverters(mod.GetType());
using (JsonSerializerExtensions.SetAllowDirectMListChanges(markedAsModified))
while (reader.TokenType == JsonToken.PropertyName)
{
if ((string)reader.Value ! == "mixins")
{
var entity = (Entity)mod;
reader.Read();
reader.Assert(JsonToken.StartObject);
reader.Read();
while (reader.TokenType == JsonToken.PropertyName)
{
var mixin = entity[(string)reader.Value !];
public List <PredictDictionary> PredictMultiple(PredictorPredictContext ctx, List <PredictDictionary> inputs)
{
using (HeavyProfiler.LogNoStackTrace("PredictMultiple"))
{
lock (lockKey)
{
var model = (TensorFlowModel)ctx.Model !;
tf.compat.v1.disable_eager_execution();
model.Session.as_default();
model.Graph.as_default();
var result = new List <PredictDictionary>();
foreach (var input in inputs)
{
NDArray inputValue = GetValueForPredict(ctx, input);
NDArray outputValuesND = model.Session.run(model.CalculatedOutput, (model.InputPlaceholder, inputValue));
float[] outputValues = outputValuesND.ToArray <float>();
PredictDictionary dic = GetPredictionDictionary(outputValues, ctx, input.Options !);
result.Add(dic);
}
return(result);
}
}
}
public IntegrityCheck?IntegrityCheck()
{
using (var log = HeavyProfiler.LogNoStackTrace("IntegrityCheck"))
{
var validators = Validator.GetPropertyValidators(GetType());
Dictionary <string, string>?dic = null;
foreach (var pv in validators.Values)
{
var error = pv.PropertyCheck(this);
if (error != null)
{
if (dic == null)
{
dic = new Dictionary <string, string>();
}
dic.Add(pv.PropertyInfo.Name, error);
}
}
if (dic == null)
{
return(null);
}
return(new Entities.IntegrityCheck(this, dic));
}
}
public override void Write(Utf8JsonWriter writer, ResultTable value, JsonSerializerOptions options)
{
using (HeavyProfiler.LogNoStackTrace("ReadJson", () => typeof(ResultTable).Name))
{
var rt = (ResultTable)value !;
writer.WriteStartObject();
writer.WritePropertyName("entityColumn");
writer.WriteStringValue(rt.EntityColumn?.Name);
writer.WritePropertyName("columns");
JsonSerializer.Serialize(writer, rt.Columns.Select(c => c.Column.Token.FullKey()).ToList(), typeof(List <string>), options);
writer.WritePropertyName("pagination");
JsonSerializer.Serialize(writer, new PaginationTS(rt.Pagination), typeof(PaginationTS), options);
writer.WritePropertyName("totalElements");
if (rt.TotalElements == null)
{
writer.WriteNullValue();
}
else
{
writer.WriteNumberValue(rt.TotalElements !.Value);
}
writer.WritePropertyName("rows");
writer.WriteStartArray();
foreach (var row in rt.Rows)
{
writer.WriteStartObject();
if (rt.EntityColumn != null)
{
writer.WritePropertyName("entity");
JsonSerializer.Serialize(writer, row.Entity, options);
}
writer.WritePropertyName("columns");
writer.WriteStartArray();
foreach (var column in rt.Columns)
{
using (EntityJsonContext.SetCurrentPropertyRouteAndEntity((column.Column.Token.GetPropertyRoute() !, null, null)))
{
JsonSerializer.Serialize(writer, row[column], options);
}
}
writer.WriteEndArray();
writer.WriteEndObject();
}
writer.WriteEndArray();
writer.WriteEndObject();
}
}
public static bool IsCompatibleWith(Attribute a, AttributeTargets targets)
{
using (HeavyProfiler.LogNoStackTrace("IsCompatibleWith"))
{
var au = AttributeUssageCache.GetOrCreate(a.GetType(), t => t.GetCustomAttribute <AttributeUsageAttribute>());
return(au != null && (au.ValidOn & targets) != 0);
}
}
internal protected virtual Table Include(Type type, PropertyRoute?route)
{
if (schema.Tables.TryGetValue(type, out var result))
{
return(result);
}
using (HeavyProfiler.LogNoStackTrace("Include", () => type.TypeName()))
{
if (type.IsAbstract)
{
throw new InvalidOperationException(ErrorIncluding(route) + $"Impossible to include in the Schema the type {type} because is abstract");
}
if (!Reflector.IsEntity(type))
{
throw new InvalidOperationException(ErrorIncluding(route) + $"Impossible to include in the Schema the type {type} because is not and Entity");
}
foreach (var t in type.Follow(a => a.BaseType))
{
if (!t.IsSerializable)
{
throw new InvalidOperationException(ErrorIncluding(route) + $"Type {t.TypeName()} is not marked as serializable");
}
}
string cleanName = schema.Settings.desambiguatedNames?.TryGetC(type) ?? Reflector.CleanTypeName(EnumEntity.Extract(type) ?? type);
if (schema.NameToType.ContainsKey(cleanName))
{
throw new InvalidOperationException(ErrorIncluding(route) + @$ "Two types have the same cleanName '{cleanName}', desambiguate using Schema.Current.Settings.Desambiguate method:
{schema.NameToType[cleanName].FullName}
{type.FullName}");
}
try
{
result = new Table(type);
schema.Tables.Add(type, result);
schema.NameToType[cleanName] = type;
schema.TypeToName[type] = cleanName;
Complete(result);
return(result);
}
catch (Exception) //Avoid half-cooked tables
{
schema.Tables.Remove(type);
schema.NameToType.Remove(cleanName);
schema.TypeToName.Remove(type);
throw;
}
}
}
public static string Dump(this object o, ShowIgnoredFields showIgnoredFields = ShowIgnoredFields.OnlyQueryables, bool showByteArrays = false)
{
using (HeavyProfiler.LogNoStackTrace("Dump"))
{
var od = new DumpVisitor(showIgnoredFields, showByteArrays);
od.DumpObject(o);
return(od.Sb.ToString());
}
}
public static string Action <TController>(this UrlHelper helper, Expression <Action <TController> > action)
where TController : Controller
{
using (var a = HeavyProfiler.LogNoStackTrace("GetRouteValuesFromExpression"))
{
RouteValueDictionary rvd = ExpressionHelper.GetRouteValuesFromExpression(action);
a.Switch("Action");
return(helper.Action(null, null, rvd));
}
}
public static FieldInfo[] InstanceFieldsInOrder(Type type)
{
using (HeavyProfiler.LogNoStackTrace("Reflector", () => type.Name))
{
var result = type.For(t => t != typeof(object), t => t.BaseType)
.Reverse()
.SelectMany(t => t.GetFields(flags | BindingFlags.DeclaredOnly).OrderBy(f => f.MetadataToken)).ToArray();
return(result);
}
}
public static T LogValue <T>(string role, Func <T> valueFactory)
{
if (!enabled)
{
return(valueFactory());
}
using (HeavyProfiler.LogNoStackTrace(role))
{
return(valueFactory());
}
}
public A FieldAttribute <A>(PropertyRoute propertyRoute) where A : Attribute
{
using (HeavyProfiler.LogNoStackTrace("FieldAttribute"))
{
if (propertyRoute.PropertyRouteType == PropertyRouteType.Root || propertyRoute.PropertyRouteType == PropertyRouteType.LiteEntity)
{
throw new InvalidOperationException("Route of type {0} not supported for this method".FormatWith(propertyRoute.PropertyRouteType));
}
return((A)FieldAttributes(propertyRoute).FirstOrDefault(a => a.GetType() == typeof(A)));
}
}
public override void WriteJson(JsonWriter writer, object?value, JsonSerializer serializer)
{
using (HeavyProfiler.LogNoStackTrace("ReadJson", () => typeof(ResultTable).Name))
{
var rt = (ResultTable)value !;
writer.WriteStartObject();
writer.WritePropertyName("entityColumn");
writer.WriteValue(rt.EntityColumn?.Name);
writer.WritePropertyName("columns");
serializer.Serialize(writer, rt.Columns.Select(c => c.Column.Token.FullKey()).ToList());
writer.WritePropertyName("pagination");
serializer.Serialize(writer, new PaginationTS(rt.Pagination));
writer.WritePropertyName("totalElements");
writer.WriteValue(rt.TotalElements);
writer.WritePropertyName("rows");
writer.WriteStartArray();
foreach (var row in rt.Rows)
{
writer.WriteStartObject();
if (rt.EntityColumn != null)
{
writer.WritePropertyName("entity");
serializer.Serialize(writer, row.Entity);
}
writer.WritePropertyName("columns");
writer.WriteStartArray();
foreach (var column in rt.Columns)
{
using (JsonSerializerExtensions.SetCurrentPropertyRoute(column.Column.Token.GetPropertyRoute()))
{
serializer.Serialize(writer, row[column]);
}
}
writer.WriteEndArray();
writer.WriteEndObject();
}
writer.WriteEndArray();
writer.WriteEndObject();
}
}
private Value GetValueForPredict(PredictorPredictContext ctx, List <PredictDictionary> inputs, DeviceDescriptor device)
{
using (HeavyProfiler.Log("GetValueForPredict", () => $"Inputs {inputs.Count} Codifications {ctx.InputCodifications.Count}"))
{
if (inputs.First().SubQueries.Values.Any(a => a.SubQueryGroups.Comparer != ObjectArrayComparer.Instance))
{
throw new Exception("Unexpected dictionary comparer");
}
float[] inputValues = new float[inputs.Count * ctx.InputCodifications.Count];
var groups = ctx.InputCodificationsByColumn;
for (int i = 0; i < inputs.Count; i++)
{
PredictDictionary input = inputs[i];
int offset = i * ctx.InputCodifications.Count;
foreach (var kvp in groups)
{
PredictorColumnBase col = kvp.Key;
object?value;
if (col is PredictorColumnMain pcm)
{
value = input.MainQueryValues.GetOrThrow(pcm.PredictorColumn);
}
else if (col is PredictorColumnSubQuery pcsq)
{
var sq = input.SubQueries.GetOrThrow(pcsq.SubQuery);
var dic = sq.SubQueryGroups.TryGetC(pcsq.Keys);
value = dic == null ? null : dic.GetOrThrow(pcsq.PredictorSubQueryColumn);
}
else
{
throw new UnexpectedValueException(col);
}
using (HeavyProfiler.LogNoStackTrace("EncodeValue"))
{
var enc = Encodings.GetOrThrow(col.Encoding);
enc.EncodeValue(value ?? CNTKDefault.GetDefaultValue(kvp.Value.FirstOrDefault()), col, kvp.Value, inputValues, offset);
}
}
}
using (HeavyProfiler.LogNoStackTrace("CreateBatch"))
return(Value.CreateBatch <float>(new int[] { ctx.InputCodifications.Count }, inputValues, device));
}
}
public static Func <object, object?>?CreateGetterUntyped(Type type, MemberInfo m)
{
using (HeavyProfiler.LogNoStackTrace("CreateGetterUntyped"))
{
if ((m as PropertyInfo)?.Let(a => !a.CanRead) ?? false)
{
return(null);
}
ParameterExpression p = Expression.Parameter(typeof(object), "p");
Type lambdaType = typeof(Func <,>).MakeGenericType(typeof(object), typeof(object));
var exp = Expression.Lambda(lambdaType, Expression.Convert(Expression.MakeMemberAccess(Expression.Convert(p, type), m), typeof(object)), p);
return((Func <object, object?>)exp.Compile());
}
}
public static Func <T, R>?CreateGetter <T, R>(MemberInfo m)
{
using (HeavyProfiler.LogNoStackTrace("CreateGetter"))
{
if (m is PropertyInfo pi && !pi.CanRead)
{
return(null);
}
ParameterExpression t = Expression.Parameter(typeof(T), "t");
var member = Expression.MakeMemberAccess(t.ConvertIfNeeded(m.DeclaringType !), m);
var exp = Expression.Lambda(typeof(Func <T, R>), member.ConvertIfNeeded(typeof(R)), t);
return((Func <T, R>)exp.Compile());
}
}
public static Action <T, P>?CreateSetter <T, P>(MemberInfo m)
{
using (HeavyProfiler.LogNoStackTrace("CreateSetter"))
{
if ((m as PropertyInfo)?.Let(a => !a.CanWrite) ?? false)
{
return(null);
}
ParameterExpression t = Expression.Parameter(typeof(T), "t");
ParameterExpression p = Expression.Parameter(typeof(P), "p");
var exp = Expression.Lambda(typeof(Action <T, P>),
Expression.Assign(Expression.MakeMemberAccess(t, m), p), t, p);
return((Action <T, P>)exp.Compile());
}
}
public ModifiableEntity DeserializeEntity(string viewState)
{
using (HeavyProfiler.LogNoStackTrace("DeserializeEntity"))
{
var array = Convert.FromBase64String(viewState);
if (EntityStateKey != null)
{
array = Decrypt(array);
}
using (var ms = new MemoryStream(array))
using (DeflateStream ds = new DeflateStream(ms, CompressionMode.Decompress))
return((ModifiableEntity)formatter.Deserialize(ds));
}
}
public static Action <object, object?>?CreateSetterUntyped(Type type, MemberInfo m)
{
using (HeavyProfiler.LogNoStackTrace("CreateSetterUntyped"))
{
if ((m as PropertyInfo)?.Let(a => !a.CanWrite) ?? false)
{
return(null);
}
ParameterExpression t = Expression.Parameter(typeof(object), "t");
ParameterExpression p = Expression.Parameter(typeof(object), "p");
var exp = Expression.Lambda(typeof(Action <object, object>),
Expression.Assign(Expression.MakeMemberAccess(Expression.Convert(t, type), m), Expression.Convert(p, m.ReturningType())), t, p);
return((Action <object, object?>)exp.Compile());
}
}
internal protected virtual Table Include(Type type, PropertyRoute route)
{
Table result;
if (schema.Tables.TryGetValue(type, out result))
{
return(result);
}
using (HeavyProfiler.LogNoStackTrace("Include", () => type.TypeName()))
{
if (type.IsAbstract)
{
throw new InvalidOperationException(route?.Let(r => "Error on field {0}: ".FormatWith(r)) + "Impossible to include in the Schema the type {0} because is abstract".FormatWith(type));
}
if (!Reflector.IsEntity(type))
{
throw new InvalidOperationException(route?.Let(r => "Error on field {0}: ".FormatWith(r)) + "Impossible to include in the Schema the type {0} because is not and Entity".FormatWith(type));
}
foreach (var t in type.Follow(a => a.BaseType))
{
if (!t.IsSerializable)
{
throw new InvalidOperationException("Type {0} is not marked as serializable".FormatWith(t.TypeName()));
}
}
result = new Table(type);
schema.Tables.Add(type, result);
string name = schema.Settings.desambiguatedNames?.TryGetC(type) ?? Reflector.CleanTypeName(EnumEntity.Extract(type) ?? type);
if (schema.NameToType.ContainsKey(name))
{
throw new InvalidOperationException(route?.Let(r => "Error on field {0}: ".FormatWith(r)) + "Two types have the same cleanName, desambiguate using Schema.Current.Settings.Desambiguate method: \r\n {0}\r\n {1}".FormatWith(schema.NameToType[name].FullName, type.FullName));
}
schema.NameToType[name] = type;
schema.TypeToName[type] = name;
Complete(result);
return(result);
}
}
static string SerializeToken(AuthToken entity)
{
using (HeavyProfiler.LogNoStackTrace("SerializeToken"))
{
var array = new MemoryStream().Using(ms =>
{
using (DeflateStream ds = new DeflateStream(ms, CompressionMode.Compress))
formatter.Serialize(ds, entity);
return(ms.ToArray());
});
array = Encrypt(array);
return(Convert.ToBase64String(array));
}
}
static TranslatedSummaryState?GetState(Type type, CultureInfo ci)
{
using (HeavyProfiler.LogNoStackTrace("GetState", () => type.Name + " " + ci.Name))
{
if (!TranslateableRoutes.GetOrThrow(type).Keys.Any(pr => AnyNoTranslated(pr, ci)))
{
return(TranslatedSummaryState.Completed);
}
if (Database.Query <TranslatedInstanceEntity>().Count(ti => ti.PropertyRoute.RootType == type.ToTypeEntity() && ti.Culture == ci.ToCultureInfoEntity()) == 0)
{
return(TranslatedSummaryState.None);
}
return(TranslatedSummaryState.Pending);
}
}
