public void Visit(IFieldDescriptor fieldDescriptor) { if (fieldDescriptor is XMLFieldDescriptor) { foreach (ICustomAction x in fieldDescriptor.CustomActions) { if (x is XMLCustomAction) { ((XMLCustomAction)x).ParentFieldDescriptor = (XMLFieldDescriptor)fieldDescriptor; } } foreach (IInvokedMethod x in fieldDescriptor.InvokedMethods) { if (x is XMLInvokedMethod) { ((XMLInvokedMethod)x).ParentFieldDescriptor = (XMLFieldDescriptor)fieldDescriptor; } } foreach (IModifiedProperty x in fieldDescriptor.ModifiedProperties) { if (x is XMLModifiedProperty) { ((XMLModifiedProperty)x).ParentFieldDescriptor = (XMLFieldDescriptor)fieldDescriptor; } } } }
private static long Hash(JToken content, IFieldDescriptor field_desc) { //TODO conflict resolve string str; string hashimport = field_desc.GetAttributeValue(Consts.c_KW_HashImport); string cellidkey = field_desc.GetAttributeValue(Consts.c_KW_CellIdKey); if ((cellidkey != null && field_desc.Type == Consts.c_Type_Guid) || (hashimport == Consts.c_KW_Guid)) { str = ((Guid)content).ToString(); } else if ((cellidkey != null && field_desc.Type == Consts.c_Type_DateTime) || (hashimport == Consts.c_KW_DateTime)) { str = ((DateTime)content).ToString("s");//XXX issue #226 } else { str = content.ToString(); } //TODO what if we're hashing a whole struct to cell id? how do we normalize? return(Trinity.Core.Lib.HashHelper.HashString2Int64(str)); }
public byte[] ToMsg() { try { var msg = new byte[PackedLength]; lenFormatter.Pack(msg, PackedLength - 4, 0); msg[4] = (byte)0xf0; msg[5] = 0x00; msg[6] = 0x21; int offset = 7; byte[] bitmap = GenerateBitmap(); Array.Copy(bitmap, 0, msg, offset, bitmap.Length); offset += bitmap.Length; foreach (var kvp in this) { IFieldDescriptor fieldDesc = GetFieldDescriptor(kvp.Key); byte[] fieldData = fieldDesc.Pack((int)kvp.Key, kvp.Value); Array.Copy(fieldData, 0, msg, offset, fieldData.Length); offset += fieldData.Length; } return(msg); } catch (FieldFormatException ffe) { throw new FieldFormatException("48.", ffe.FieldNumber, ffe.Message); } }
public void AddColumn(IDataContext db, IFieldDescriptor field) { if (db == null) { throw new ArgumentNullException("session"); } if (field == null) { throw new ArgumentNullException("field"); } var sqlType = MssqlSqlTypeConverter.GetSqlType(field); var sql = new SqlString("alter table [", this.Name, "] add [", field.Name, "] ", sqlType); db.Execute(sql); //TODO //this.SetColumnComment(db, field); if (field.IsUnique) { this.AddUniqueConstraint(db, field.Name); } }
/// <inheritdoc /> public void SetFieldValue(IFieldDescriptor field, IConcreteValue value) { var typeMemoryLayout = _memoryAllocator.GetTypeMemoryLayout(field.DeclaringType); var fieldMemoryLayout = typeMemoryLayout[field.Resolve()]; this.WriteStruct((int)fieldMemoryLayout.Offset, _memoryAllocator, fieldMemoryLayout.ContentsLayout, value); }
// ------------------------- // Implementation rationale // ------------------------- // // Objects in .NET are implemented as a single memory region containing all fields and are referenced by // a single pointer to the first byte of the object. Getting and setting field values of an object is done // by reading from this base pointer + the field offset. In C this would be something like the following: // // *(MyFieldType*) (ptr_to_TypeA_object + offset_MyField); // // or using pointer notation: // // ptr_to_TypeA_object->MyField // // Although C# represents itself as a type-safe language, CIL is not. As a result, it is possible for a // ldfld instruction to perform type confusion, and read "non-existing" fields from a type, by pushing // an object reference of type A, and referencing a field from another type B in the operand of the // ldfld instruction. For example, the following CIL snippet runs fine: // // newobj void TypeA::.ctor() // ldfld MyFieldType TypeB::MyField // // The runtime (tested on Mono and .NET Core) will reinterpret the pushed object as TypeB, even though it is // a pointer to TypeA, and use the field offset as if it was actually an instance of TypeB: // // ((TypeB*) ptr_to_TypeA_object)->MyField // // which is equivalent to: // // *(MyFieldType*) (ptr_to_TypeA_object + offset_MyField)) // // For this reason, we do not store the memory type layout of the current object within this class, but rather // query the memory allocator that was used to create this LLE object for the memory layout of the field's // declaring type. /// <inheritdoc /> public IConcreteValue GetFieldValue(IFieldDescriptor field) { var typeMemoryLayout = _memoryAllocator.GetTypeMemoryLayout(field.DeclaringType); var fieldMemoryLayout = typeMemoryLayout[field.Resolve()]; return(this.ReadStruct((int)fieldMemoryLayout.Offset, _memoryAllocator, fieldMemoryLayout.ContentsLayout)); }
private async Task WriteObjectPropertyDeserializationAsync( CodeWriter writer, IResultParserTypeDescriptor possibleType, string jsonElement, ITypeLookup typeLookup) { for (int i = 0; i < possibleType.ResultDescriptor.Fields.Count; i++) { IFieldDescriptor fieldDescriptor = possibleType.ResultDescriptor.Fields[i]; await writer.WriteIndentAsync().ConfigureAwait(false); if (fieldDescriptor.Type.NamedType().IsLeafType()) { ITypeInfo typeInfo = typeLookup.GetTypeInfo( fieldDescriptor.Type, true); string deserializeMethod = SerializerNameUtils.CreateDeserializerName( fieldDescriptor.Type); await writer.WriteAsync(deserializeMethod).ConfigureAwait(false); await writer.WriteAsync('(').ConfigureAwait(false); await writer.WriteAsync(jsonElement).ConfigureAwait(false); await writer.WriteAsync(", \"").ConfigureAwait(false); await writer.WriteAsync(fieldDescriptor.ResponseName).ConfigureAwait(false); await writer.WriteAsync("\")").ConfigureAwait(false); } else { await writer.WriteAsync("Parse").ConfigureAwait(false); await writer.WriteAsync(GetPathName(fieldDescriptor.Path)) .ConfigureAwait(false); await writer.WriteAsync('(').ConfigureAwait(false); await writer.WriteAsync(jsonElement).ConfigureAwait(false); await writer.WriteAsync(", \"").ConfigureAwait(false); await writer.WriteAsync(fieldDescriptor.ResponseName).ConfigureAwait(false); await writer.WriteAsync("\")").ConfigureAwait(false); } if (i < possibleType.ResultDescriptor.Fields.Count - 1) { await writer.WriteAsync(',').ConfigureAwait(false); } await writer.WriteLineAsync().ConfigureAwait(false); } }
public static string GetSqlType(IFieldDescriptor field) { if (field == null) { throw new ArgumentNullException("field"); } var func = mapping[field.Type]; var sb = new StringBuilder(); sb.Append(func(field)); if (field.IsRequired) { sb.Append(' '); sb.Append("not null"); } if (field.IsUnique) { sb.Append(' '); sb.Append("unique"); } return(sb.ToString()); }
private void Verify(IFieldDescriptor field, ICliValue expectedValue) { var result = Dispatcher.Execute(ExecutionContext, new CilInstruction(CilOpCodes.Ldsfld, field)); Assert.True(result.IsSuccess); Assert.Equal(expectedValue, ExecutionContext.ProgramState.Stack.Top); }
public static IFieldDescriptor Resolver <TResult>( this IFieldDescriptor descriptor, Func <Task <TResult> > fieldResolver) { return(descriptor.Type(typeof(TResult), false) .Resolver((ctx, ct) => fieldResolver())); }
private void SetAndVerify(IFieldDescriptor field, IConcreteValue fieldValue, ICliValue expectedValue) { var environment = ExecutionContext.GetService <ICilRuntimeEnvironment>(); environment.StaticFieldFactory.Get(field).Value = fieldValue; Verify(field, expectedValue); }
private IConcreteValue GetInitialFieldValue(IFieldDescriptor field) { var definition = field.Resolve(); if (definition != null) { // Check if the field has an initial value through a Constant row. var constant = definition.Constant; if (constant?.Value != null) { return(ObjectToCtsValue( constant.Value.Data, definition.Module.CorLibTypeFactory.FromElementType(constant.Type))); } // Check if the field has an initial value through a field RVA row. if (definition.HasFieldRva && definition.FieldRva != null && definition.FieldRva is IReadableSegment readableSegment) { return(ObjectToCtsValue( readableSegment.ToArray(), field.Signature.FieldType)); } } return(_valueFactory.CreateValue(field.Signature.FieldType, false)); }
public void AddColumn(IDataContext db, IFieldDescriptor field) { if (db == null) { throw new ArgumentNullException("session"); } if (field == null) { throw new ArgumentNullException("field"); } var sqlType = PgSqlTypeConverter.GetSqlType(field); var sql = String.Format(CultureInfo.InvariantCulture, @"alter table ""{0}"" add column ""{1}"" {2}", this.Name, field.Name, sqlType); db.Execute(SqlString.Parse(sql)); this.SetColumnComment(db, field); if (field.IsUnique) { this.AddUniqueConstraint(db, field.Name); } }
public static IFieldDescriptor Resolver <TResult>( this IFieldDescriptor descriptor, Func <Task <TResult> > fieldResolver) { return(descriptor.Resolver((ctx, ct) => fieldResolver(), typeof(NativeType <TResult>))); }
public static IFieldDescriptor Resolver <TResult>( this IFieldDescriptor descriptor, Func <IResolverContext, TResult> fieldResolver) { return(descriptor .Type <NativeType <TResult> >() .Resolver((ctx, ct) => fieldResolver(ctx), typeof(NativeType <TResult>))); }
/// <inheritdoc /> public int GetHashCode(IFieldDescriptor obj) { unchecked { int hashCode = obj.Name == null ? 0 : obj.Name.GetHashCode(); hashCode = (hashCode * 397) ^ GetHashCode(obj.DeclaringType); hashCode = (hashCode * 397) ^ GetHashCode(obj.Signature); return(hashCode); } }
private static FieldInfo GetFieldInfo(IFieldDescriptor fieldDescriptor, IClassConfiguration parent) { Type t = Type.GetType(parent.ClassName); FieldInfo f = t.GetField(fieldDescriptor.FieldName, BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance); return(f); }
private void SetColumnComment(IDataContext db, IFieldDescriptor field) { if (!string.IsNullOrEmpty(field.Label)) { //添加注释 var commentSql = String.Format(CultureInfo.InvariantCulture, @"comment on column ""{0}"".""{1}"" is '{2}'", this.Name, field.Name, field.Label.SqlEscape()); db.Execute(SqlString.Parse(commentSql)); } }
/// <summary> /// Creates a new instance of the <see cref="StaticField"/> class. /// </summary> /// <param name="field">The field to encapsulate </param> public StaticField(IFieldDescriptor field) { if (field == null) { throw new ArgumentNullException(nameof(field)); } if (field.Signature.HasThis) { throw new ArgumentException("Field must be static."); } Field = field; }
/// <summary> /// Verifies and inserts an instruction into the collection that references a field. /// </summary> /// <param name="index">The zero-based index at which the instruction should be inserted at.</param> /// <param name="code">The field opcode.</param> /// <param name="field">The field referenced by the instruction.</param> /// <returns>The created instruction.</returns> /// <exception cref="InvalidCilInstructionException"> /// Occurs when the provided operation is not a field opcode. /// </exception> /// <exception cref="ArgumentNullException"> /// Occurs when <paramref name="field"/> is null. /// </exception> public CilInstruction Insert(int index, CilOpCode code, IFieldDescriptor field) { if (code.OperandType != CilOperandType.InlineField && code.OperandType != CilOperandType.InlineTok) { throw new InvalidCilInstructionException(code); } if (field is null) { throw new ArgumentNullException(nameof(field)); } return(InsertAndReturn(index, code, field)); }
private void SetColumnComment(IDataContext db, IFieldDescriptor field) { if (!string.IsNullOrEmpty(field.Label)) { //添加注释 var commentSql = new SqlString( "comment on column [", this.Name, "].[", field.Name, "] is '", field.Label.SqlEscape(), "'"); db.Execute(commentSql); } }
public void Visit(IFieldDescriptor fieldDescriptor) { if (fieldDescriptor.FieldName == null) { throw new ContextConfigurationException("IFieldDescriptor without definition of 'FieldName' found"); } IClassConfiguration parent = fieldDescriptor.ParentClassConfiguration; FieldInfo f = GetFieldInfo(fieldDescriptor, parent); if (f == null) { throw new ContextConfigurationException("Field '" + fieldDescriptor.FieldName + "' not found in class '" + parent.ClassName + "'"); } }
/// <inheritdoc /> public bool Equals(IFieldDescriptor x, IFieldDescriptor y) { if (ReferenceEquals(x, y)) { return(true); } if (ReferenceEquals(x, null) || ReferenceEquals(y, null)) { return(false); } return(x.Name == y.Name && Equals(x.DeclaringType, y.DeclaringType) && Equals(x.Signature, y.Signature)); }
public static StructField ConvertFromFieldDescriptor(IFieldDescriptor fd) { if (fd == null) { return(null); } var type = DataType.ConvertFromType(fd.Type); return(new StructField { Name = fd.Name, Type = type, Nullable = fd.Optional || (type is NullableValueType) }); }
private void DeclareFields( IObjectTypeDescriptor typeDescriptor, string typeName, IReadOnlyCollection <FieldDefinitionNode> fieldDefinitions) { foreach (FieldDefinitionNode fieldDefinition in fieldDefinitions) { IFieldDescriptor fieldDescriptor = typeDescriptor .Field(fieldDefinition.Name.Value) .Description(fieldDefinition.Description?.Value) .Type(fieldDefinition.Type) .SyntaxNode(fieldDefinition); DeclareFieldArguments(fieldDescriptor, fieldDefinition); } }
private void DeclareFieldArguments( IFieldDescriptor fieldDescriptor, FieldDefinitionNode fieldDefinition) { foreach (InputValueDefinitionNode inputFieldDefinition in fieldDefinition.Arguments) { fieldDescriptor.Argument(inputFieldDefinition.Name.Value, a => { a.Description(inputFieldDefinition.Description?.Value) .Type(inputFieldDefinition.Type) .DefaultValue(inputFieldDefinition.DefaultValue) .SyntaxNode(inputFieldDefinition); }); } }
public void Visit(IModifiedProperty modifiedProperty) { if (modifiedProperty.PropertyName == null) { throw new ContextConfigurationException("IModifiedProperty without definition of 'PropertyName' found"); } IFieldDescriptor p = modifiedProperty.ParentFieldDescriptor; FieldInfo f = GetFieldInfo(p, p.ParentClassConfiguration); Type t = f.FieldType; PropertyInfo pi = t.GetProperty(modifiedProperty.PropertyName, BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance); if (pi == null) { throw new ContextConfigurationException("Fieldtype of field '" + p.FieldName + "' in class '" + p.ParentClassConfiguration.ClassName + "' does not define property '" + modifiedProperty.PropertyName + "'"); } }
public ICell ImportEntity(string type, string content, long?parent_id = null) { var fields = parser.CsvSplit(content); if (fields.Count != m_fieldNames.Count) { throw new ImporterException("Invalid record. The number of a field ({0}) must equal to {1}: {2}", fields.Count, m_fieldNames.Count, content); } var jsonObj = new JObject(); var fieldDescDict = GetFieldDescriptors(type); IFieldDescriptor fieldDesc = null; for (int colIndex = 0; colIndex < m_fieldNames.Count; colIndex++) { var fieldName = m_fieldNames[colIndex]; string fieldValue = fields[colIndex]; if (fieldValue == null || !fieldDescDict.TryGetValue(fieldName, out fieldDesc)) { // Ignore this field if it's value is null or could not find the descriptor. continue; } string csvArraySplitBy = fieldDesc.GetAttributeValue(Consts.c_KW_CsvArray); if (fieldValue == null || csvArraySplitBy == null) { jsonObj[fieldName] = fieldValue; } else { var elements = fieldValue.Split(csvArraySplitBy.ToCharArray(), StringSplitOptions.RemoveEmptyEntries); var jsonArray = new JArray(); foreach (var elem in elements) { jsonArray.Add(elem); } jsonObj[fieldName] = jsonArray; } } return(m_jsonImporter.ImportEntity(type, jsonObj.ToString(), parent_id)); }
/// <summary> /// Gets or creates an instance of a static field. /// </summary> /// <param name="field">The field to encapsulate.</param> /// <returns>The static field.</returns> public StaticField Get(IFieldDescriptor field) { if (field is null) { throw new ArgumentNullException(nameof(field)); } if (field.Signature.HasThis) { throw new ArgumentException("Field has the HasThis flag set in the field signature."); } StaticField staticField; while (!_cache.TryGetValue(field, out staticField)) { _cache.TryAdd(field, new StaticField(field)); } return(staticField); }
public void Visit(IInvokedMethod invokedMethod) { if (invokedMethod.MethodName == null) { throw new ContextConfigurationException("InvokedMethod without definition of 'MethodName' found"); } IFieldDescriptor p = invokedMethod.ParentFieldDescriptor; FieldInfo f = GetFieldInfo(p, p.ParentClassConfiguration); Type t = f.FieldType; MethodInfo m = t.GetMethod(invokedMethod.MethodName, BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance); if (m == null) { throw new ContextConfigurationException("Fieldtype of field '" + p.FieldName + "' in class '" + p.ParentClassConfiguration.ClassName + "' does not define method '" + invokedMethod.MethodName + "'"); } }
public void Visit(IFieldDescriptor fieldDescriptor) { if(fieldDescriptor.FieldName == null) { throw new ContextConfigurationException("IFieldDescriptor without definition of 'FieldName' found"); } IClassConfiguration parent = fieldDescriptor.ParentClassConfiguration; FieldInfo f = GetFieldInfo(fieldDescriptor, parent); if (f == null) { throw new ContextConfigurationException("Field '" + fieldDescriptor.FieldName + "' not found in class '" + parent.ClassName+"'"); } }
public Int32 CompareTo(IFieldDescriptor fieldDescriptor) { return fieldDescriptor is FieldDescriptor ? String.Compare(Id, fieldDescriptor.Id, StringComparison.Ordinal) : -1; }
public void Visit(IFieldDescriptor fieldDescriptor) { if (fieldDescriptor is XMLFieldDescriptor) { foreach (ICustomAction x in fieldDescriptor.CustomActions) { if (x is XMLCustomAction) { ((XMLCustomAction)x).ParentFieldDescriptor = (XMLFieldDescriptor)fieldDescriptor; } } foreach (IInvokedMethod x in fieldDescriptor.InvokedMethods) { if (x is XMLInvokedMethod) { ((XMLInvokedMethod)x).ParentFieldDescriptor = (XMLFieldDescriptor)fieldDescriptor; } } foreach (IModifiedProperty x in fieldDescriptor.ModifiedProperties) { if (x is XMLModifiedProperty) { ((XMLModifiedProperty)x).ParentFieldDescriptor = (XMLFieldDescriptor)fieldDescriptor; } } } }
private static FieldInfo GetFieldInfo(IFieldDescriptor fieldDescriptor, IClassConfiguration parent) { Type t = Type.GetType(parent.ClassName); FieldInfo f = t.GetField(fieldDescriptor.FieldName, BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance); return f; }