/// <summary> /// Creates a collector for a group. /// </summary> /// <param name="other">Parent collector</param> /// <param name="group">The field that starts the group</param> private TraceLoggingMetadataCollector( TraceLoggingMetadataCollector other, FieldMetadata group) { this.impl = other.impl; this.currentGroup = group; }
/// <summary> /// Indicates if other field metadata refers to the same data as this.</summary> /// <param name="other">Other field metadata</param> /// <returns>True iff other field metadata is equivalent to this</returns> public bool Equivalent(FieldMetadata other) { return other != null && Index == other.Index && DefiningType == other.DefiningType; }
public void ClassWithAttributesTest() { TypeMetadata attributeClass = ReflectorTestClass.Reflector.MyNamespace.Types.Single(x => x.TypeName == "ClassWithAttribute"); FieldMetadata fieldWithAttribute = attributeClass.Fields.Single(x => x.Name == "FieldWithAttribute"); Assert.AreEqual("FieldWithAttribute", fieldWithAttribute.Name); Assert.AreEqual(1, attributeClass.Attributes.Count()); }
private static string _getLabelWithNamespace(FieldMetadata f) { if (String.IsNullOrEmpty(f.Namespace)) { return(f.Label); } return(string.Format("{0}::{1}", f.Namespace, f.Label)); }
private object ReadFieldValue(ClassMetadata classMetadata, FieldMetadata field) { if (!classMetadata.SeekToField(this, field)) { return(null); } return(field.Read(this)); }
internal virtual void Unmarshall(Transaction a_trans) { if (i_classMetadataID != 0) { ClassMetadata yc = a_trans.Container().ClassMetadataForID(i_classMetadataID); _fieldMetadata = (FieldMetadata)yc._aspects[_fieldHandle]; } }
public VMFieldMetadata(FieldMetadata field) { fieldMetadata = field; if (CanLoadChildren()) { Children.Add(null); } }
/// <summary> /// Gets the decimal precision/scale sql command. /// </summary> /// <param name="field">The field metadata.</param> /// <returns>Returns the command.</returns> private string GetDecimalPrecisionCommand(FieldMetadata field) { if (field.FieldType == "decimal") { return($"({field.DecimalPrecision}, {field.DecimalScale})"); } return(string.Empty); }
private int CompareByField(int x, int y, IList path) { object xFieldValue = GetFieldValue(x, path); object yFieldValue = GetFieldValue(y, path); FieldMetadata field = ((FieldMetadata)path[path.Count - 1]); return(field.PrepareComparison(_transaction.Context(), xFieldValue).CompareTo(yFieldValue )); }
private void AddFieldConstraint(ClassMetadata containingClass, FieldMetadata field ) { QConClass qcc = new QConClass(this._enclosing._trans, null, field.QField(this._enclosing ._trans), containingClass.ClassReflector()); this._enclosing.AddConstraint(qcc); this._enclosing.ToConstraint(this._enclosing.i_constraints).Or(qcc); }
/// <summary> /// Gets the complex field name. /// </summary> /// <param name="fieldMetadata">The field metadata.</param> /// <returns>Returns the name of the field.</returns> public static string GetComplexFieldName(this FieldMetadata fieldMetadata) { if (!fieldMetadata.IsComplexFieldType) { return(fieldMetadata.Name); } return(fieldMetadata.Name.Substring(3, fieldMetadata.Name.Length - 6)); }
public static void InitPickList(FieldMetadata fieldDef, RadComboBox field) { if (fieldDef != null) { foreach (var pickListEntry in fieldDef.PickListEntries) { field.Items.Add(new RadComboBoxItem(pickListEntry.Text, pickListEntry.Value)); } } }
private void CheckStrongType(string fieldName, Type type) { FieldMetadata fieldMetaData = _metadata[fieldName]; Type compareType = DataTypeConvert.ToSysType(fieldMetaData.DataType, fieldMetaData.Nullable); if (type != compareType) { throw new ArgumentException("Type not match", "type"); } }
private FieldMetadata FieldMetadata() { if (this._fieldMetaData != null) { return(this._fieldMetaData); } this._fieldMetaData = this.ClassMetadata().FieldMetadataForName(this._enclosing._fieldName ); return(this._fieldMetaData); }
protected virtual void AssertFieldIndex(int id) { IReflectClass claxx = Reflector().ForClass(typeof(TPFieldIndexConsistencyTestCaseBase.Item )); ClassMetadata classMetadata = FileSession().ClassMetadataForReflectClass(claxx); FieldMetadata field = classMetadata.FieldMetadataForName(IdFieldName); IBTreeRange indexRange = field.Search(Trans(), id); Assert.AreEqual(1, indexRange.Size()); }
private FieldMetadata FieldMetadata() { if (_fieldMetaData != null) { return(_fieldMetaData); } _fieldMetaData = ClassMetadata().FieldMetadataForName(_enclosing._fieldName ); return(_fieldMetaData); }
protected override void ProcessAspect(ClassAspect aspect, int currentSlot, bool isNull ) { FieldMetadata field = (FieldMetadata)aspect; if (!isNull) { field.AttemptUpdate(context); } }
internal virtual bool Attach(QQuery query, string a_field) { Db4objects.Db4o.Internal.Query.Processor.QCon qcon = this; ClassMetadata yc = GetYapClass(); bool[] foundField = new bool[] { false }; ForEachChildField(a_field, new _IVisitor4_101(foundField, query)); if (foundField[0]) { return(true); } QField qf = null; if (yc == null || yc.HoldsAnyClass()) { int[] count = new int[] { 0 }; FieldMetadata[] yfs = new FieldMetadata[] { null }; i_trans.Container().ClassCollection().AttachQueryNode(a_field, new _IVisitor4_119 (yfs, count)); if (count[0] == 0) { return(false); } if (count[0] == 1) { qf = yfs[0].QField(i_trans); } else { qf = new QField(i_trans, a_field, null, 0, 0); } } else { if (yc.IsTranslated()) { i_trans.Container()._handlers.DiagnosticProcessor().DescendIntoTranslator(yc, a_field ); } FieldMetadata yf = yc.FieldMetadataForName(a_field); if (yf != null) { qf = yf.QField(i_trans); } if (qf == null) { qf = new QField(i_trans, a_field, null, 0, 0); } } QConPath qcp = new QConPath(i_trans, qcon, qf); query.AddConstraint(qcp); qcon.AddConstraint(qcp); return(true); }
public void TestIndexingLowLevel() { LocalObjectContainer container = Fixture().FileSession(); ClassMetadata classMetadata = container.ClassMetadataForReflectClass(container.Reflector().ForClass(typeof(ValueTypeHolder))); FieldMetadata fieldMetadata = classMetadata.FieldMetadataForName("Value"); Assert.IsTrue(fieldMetadata.CanLoadByIndex(), WithTypeName("Typehandler for type {0} should be indexable.")); BTree index = fieldMetadata.GetIndex(container.SystemTransaction()); Assert.IsNotNull(index, WithTypeName("No btree index found for field of type {0} .")); }
private string GetFieldDefinition(FieldMetadata field, bool includeIdentity) { var type = GetSqlType(field); var fieldSqlDefinition = string.Format("[{0}] {1} {2} {3}" , field.SchemaName , type , includeIdentity && field.IsPrimaryKey && field is BigIntFieldMetadata ? "IDENTITY(1, 1)" : null , field.IsPrimaryKey || field.IsMandatory ? "NOT NULL" : "NULL"); return(fieldSqlDefinition); }
private void AddField(FieldMetadata fieldMetadata) { this.Tags = EventFieldTags.None; this.bufferedArrayFieldCount++; this.impl.fields.Add(fieldMetadata); if (this.currentGroup != null) { this.currentGroup.IncrementStructFieldCount(); } }
//internal void AddProperty<T>(List<FieldMetadata> properties, string sharePointFieldName, object value, bool managedMetaDataType) //{ // FieldMetadata propertyValue = CreateFieldMetadataInstance(properties, sharePointFieldName, managedMetaDataType); // propertyValue.Value = ConvertCRMValueToSharePointValue<T>(value); //} private static FieldMetadata CreateFieldMetadataInstance(List <FieldMetadata> properties, string sharePointFieldName, bool managedMetaDataType) { FieldMetadata propertyValue = new FieldMetadata(); propertyValue.Name = sharePointFieldName; propertyValue.Value = null; propertyValue.ManagedMetadataType = managedMetaDataType; properties.Add(propertyValue); return(propertyValue); }
static public void UpdateEntityFieldDef(Guid fieldDefId, string caption) { FieldMetadata metadata = MetadataManager.GetDataNode(fieldDefId) as FieldMetadata; if (metadata == null) { return; } metadata.Caption = caption; MetadataManager.UpdateDataNode(metadata); }
public void TestIndexingLowLevel() { LocalObjectContainer container = Fixture().FileSession(); ClassMetadata classMetadata = container.ClassMetadataForReflectClass(container.Reflector().ForClass(typeof(Item))); FieldMetadata fieldMetadata = classMetadata.FieldMetadataForName("_asByte"); Assert.IsTrue(fieldMetadata.CanLoadByIndex(), "EnumTypeHandler should be indexable."); BTree index = fieldMetadata.GetIndex(container.SystemTransaction()); Assert.IsNotNull(index, "No btree index found for enum field."); }
public override IEnumerable <IFieldMetadata> GetFieldMetadata(string recordType) { lock (_lockObject) { if (!FieldMetadata.ContainsKey(recordType)) { FieldMetadata.Add(recordType, RecordMetadataFactory.GetClassFieldMetadata(Type.GetType(recordType))); var fieldMetadata = FieldMetadata[recordType]; } return(FieldMetadata[recordType]); } }
/// <summary> /// Gets a query parameter based on the specified name, value and field metadata. /// </summary> /// <param name="name">The name.</param> /// <param name="value">The value.</param> /// <param name="fieldMetadata">The field metadata.</param> /// <returns>Returns a QueryParameter instance.</returns> public static QueryParameter GetQueryParameter(string name, object value, FieldMetadata fieldMetadata) { var parameter = new QueryParameter(name, value, fieldMetadata.GetSqlDbType(), !fieldMetadata.Mandatory, fieldMetadata.MaxLength); if (fieldMetadata.FieldType == "decimal") { parameter.Precision = fieldMetadata.DecimalPrecision; parameter.Scale = fieldMetadata.DecimalScale; } return(parameter); }
public void DownloadCsv() { var newFileName = ApplicationController.GetSaveFileName(string.Format("{0}", RecordService.GetCollectionName(RecordType)), "csv"); ApplicationController.DoOnAsyncThread(() => { try { LoadingViewModel.IsLoading = true; if (!string.IsNullOrWhiteSpace(newFileName)) { var folder = Path.GetDirectoryName(newFileName); var fileName = Path.GetFileName(newFileName); var fields = FieldMetadata.ToArray(); var started = DateTime.UtcNow; var labelFuncDictionary = new Dictionary <string, Func <string, string> >(); foreach (var fm in FieldMetadata) { labelFuncDictionary.Add(fm.AliasedFieldName ?? fm.FieldName, s => fm.OverrideLabel ?? RecordService.GetFieldLabel(fm.FieldName, fm.AltRecordType ?? RecordType)); } var displayFuncDictionary = new Dictionary <string, Func <object, string, string> >(); foreach (var fm in FieldMetadata) { displayFuncDictionary.Add(fm.AliasedFieldName ?? fm.FieldName, (o, s) => RecordService.GetFieldAsDisplayString(fm.AltRecordType ?? RecordType, fm.FieldName, ((IRecord)o).GetField(s))); } CsvUtility.CreateCsv(folder, fileName, GetGridRecords(true).Records, fields.Select(f => f.AliasedFieldName ?? f.FieldName), (f) => labelFuncDictionary[f](f), (r, f) => displayFuncDictionary[f](r, f)); ApplicationController.LogEvent("Download CSV", new Dictionary <string, string> { { "Is Completed Event", true.ToString() }, { "Type", RecordType }, { "Seconds Taken", (DateTime.UtcNow - started).TotalSeconds.ToString() }, }); ApplicationController.StartProcess("explorer.exe", "/select, \"" + Path.Combine(folder, fileName) + "\""); } } catch (Exception ex) { ApplicationController.ThrowException(ex); } finally { LoadingViewModel.IsLoading = false; } }); }
private static FieldMetadata InstantiateFieldWithType( FieldMetadata fieldTemplate, TypeMetadata typeMetadata) { return(new FieldMetadata( fieldTemplate.Name, fieldTemplate.ProtectionLevel, fieldTemplate.IsStatic) { GenericParameters = InstantiateGenericParameterListWithType(fieldTemplate.GenericParameters, typeMetadata) }); }
private bool IsHiddenProperty(FieldMetadata fieldMeta) { if (fieldMeta.PropertyInfo.Name == "StartupProperty") { return(IsStartupMode); } if (fieldMeta.PropertyInfo.Name == "RuntimeProperty") { return(IsRuntimeMode); } return(true); }
public FieldNodeViewModel(FieldMetadata metadata) { _metadata = metadata; Name = metadata.Name; Kind = TypeKind.Field; LoadChildrenCommand = new RelayCommand(() => { Children = new List <NodeViewModelBase> { TypeMetadataToViewModel(_metadata.TypeMetadata) }; }); }
static public void DeleteEntityFieldDef(Guid fieldDefId) { FieldMetadata metadata = MetadataManager.GetDataNode(fieldDefId) as FieldMetadata; if (metadata == null) { return; } if (metadata.TenantId == DataModelContext.TenantId) { MetadataManager.DeleteDataNode(metadata); } }
public QField(Transaction a_trans, string name, FieldMetadata fieldMetadata, int classMetadataID, int a_index) { // C/S only i_trans = a_trans; i_name = name; _fieldMetadata = fieldMetadata; i_classMetadataID = classMetadataID; _fieldHandle = a_index; if (_fieldMetadata != null) { if (!_fieldMetadata.Alive()) { _fieldMetadata = null; } } }
/// <summary> /// Initializes a new instance. /// </summary> /// <param name="component">The component the state machine belongs to.</param> /// <param name="stateField">The field that should be used to store the component's current state.</param> /// <param name="states">The states of the state machine.</param> /// <param name="initialStates">The initial states of the state machine.</param> /// <param name="transitions">The transitions of the state machine.</param> internal StateMachineMetadata(Component component, FieldMetadata stateField, IEnumerable<StateMetadata> states, IEnumerable<StateMetadata> initialStates, IEnumerable<TransitionMetadata> transitions) { Requires.NotNull(component, () => component); Requires.NotNull(states, () => states); Requires.NotNull(transitions, () => transitions); Requires.NotNull(stateField, () => stateField); var stateArray = states.ToArray(); var initialStatesArray = initialStates.Distinct().ToArray(); var transitionArray = transitions.ToArray(); Requires.That(initialStatesArray.Length > 0, "An initial state must be set for the state machine."); _component = component; States = stateArray; InitialStates = initialStatesArray; Transitions = transitionArray; StateField = stateField; _component.StateMetadata = InitialStates[_random.Next(0, InitialStates.Count)]; }
/// <summary> /// Call this method to add a group to the event and to return /// a new metadata collector that can be used to add fields to the /// group. After all of the fields in the group have been written, /// switch back to the original metadata collector to add fields /// outside of the group. /// Special-case: if name is null, no group is created, and AddGroup /// returns the original metadata collector. This is useful when /// adding the top-level group for an event. /// Note: do not use the original metadata collector while the group's /// metadata collector is in use, and do not use the group's metadata /// collector after switching back to the original. /// </summary> /// <param name="name"> /// The name of the group. If name is null, the call to AddGroup is a /// no-op (collector.AddGroup(null) returns collector). /// </param> /// <returns> /// A new metadata collector that can be used to add fields to the group. /// </returns> public TraceLoggingMetadataCollector AddGroup(string name) { TraceLoggingMetadataCollector result = this; if (name != null || // Normal. this.BeginningBufferedArray) // Error, FieldMetadata's constructor will throw the appropriate exception. { var newGroup = new FieldMetadata( name, TraceLoggingDataType.Struct, 0, this.BeginningBufferedArray); this.AddField(newGroup); result = new TraceLoggingMetadataCollector(this, newGroup); } return result; }
public _IVisitor4_119(FieldMetadata[] yfs, int[] count) { this.yfs = yfs; this.count = count; }
// do nothing protected abstract void Process(FieldMetadata field);
internal virtual void Unmarshall(Transaction a_trans) { if (i_classMetadataID != 0) { var yc = a_trans.Container().ClassMetadataForID(i_classMetadataID); _fieldMetadata = (FieldMetadata) yc._aspects[_fieldHandle]; } }
private object ReadFieldValue(int id, FieldMetadata field) { var buffer = BufferFor(id); var handlerVersion = field.ContainingClass().SeekToField(_transaction, buffer, field); if (handlerVersion == HandlerVersion.Invalid) { return null; } var context = new QueryingReadContext(_transaction, handlerVersion ._number, buffer, id); return field.Read(context); }
private void FieldNotFound() { if (_classMetadata.HoldsAnyClass()) { // retry finding the field on reading the value _fieldMetadata = null; } else { // we can't get a value for the field, comparisons should definitely run against null _fieldMetadata = new NullFieldMetadata(); } _handlerVersion = HandlerRegistry.HandlerVersion; }
/// <summary> /// Create a new FieldMetadata object. /// </summary> /// <param name="fieldName">Initial value of FieldName.</param> /// <param name="clrType">Initial value of ClrType.</param> public static FieldMetadata CreateFieldMetadata(string fieldName, string clrType) { FieldMetadata fieldMetadata = new FieldMetadata(); fieldMetadata.FieldName = fieldName; fieldMetadata.ClrType = clrType; return fieldMetadata; }
public virtual object ReadFieldValue(FieldMetadata field) { ReadBuffer(ObjectId()); if (Buffer() == null) { return null; } var classMetadata = ReadObjectHeader(); if (classMetadata == null) { return null; } return ReadFieldValue(classMetadata, field); }
/// <summary> /// Transforms the <paramref name="field" />. /// </summary> private static Ssm.Field Transform(FieldMetadata field) { var values = field.InitialValues.Select(value => { if (field.Type == typeof(bool)) return Ssm.InitVal.NewBoolVal((bool)value); if (field.Type == typeof(int)) return Ssm.InitVal.NewIntVal((int)value); if (field.Type == typeof(double)) return Ssm.InitVal.NewDoubleVal((double)value); if (field.Type.IsEnum) return Ssm.InitVal.NewIntVal(((IConvertible)value).ToInt32(CultureInfo.InvariantCulture)); Assert.NotReached("Unsupported type '{0}'.", field.Type.FullName); return null; }); return Ssm.CreateField(field.Name, Transform(field.Type), values); }
/// <summary> /// There are no comments for FieldMetadataSet in the schema. /// </summary> public void AddToFieldMetadataSet(FieldMetadata fieldMetadata) { base.AddObject("FieldMetadataSet", fieldMetadata); }
private void AddFieldConstraint(ClassMetadata containingClass, FieldMetadata field ) { var qcc = new QConClass(_enclosing._trans, null, field.QField(_enclosing ._trans), containingClass.ClassReflector()); _enclosing.AddConstraint(qcc); _enclosing.ToConstraint(_enclosing.i_constraints).Or(qcc); }
private static void LoadEntityMetaData(string folder, Entity entity) { XmlDocument document = null; var fileName = Path.Combine(folder, entity.Name + ".metadata.xml"); if (!File.Exists(fileName)) return; try { document = new XmlDocument(); document.Load(fileName); } catch (Exception ex) { //Do Nothing MessageBox.Show("The file '" + fileName + "' is not valid and could not be loaded!", "Load Error!", MessageBoxButtons.OK, MessageBoxIcon.Error); return; } foreach (XmlNode n in document.DocumentElement) { if (n.Name == "fieldset") { foreach (XmlElement n2 in n.ChildNodes) { var columnid = XmlHelper.GetAttributeValue(n2, "columnid", Guid.Empty); var field = entity.Fields.FirstOrDefault(x => x.Id == columnid); if (field != null) { var fieldMD = new FieldMetadata(entity.Partition); fieldMD.Key = XmlHelper.GetAttributeValue(n2, "key", fieldMD.Key); fieldMD.Value = XmlHelper.GetAttributeValue(n2, "value", fieldMD.Value); field.FieldMetadata.Add(fieldMD); } } } else { var newMD = new EntityMetadata(entity.Partition); newMD.Key = XmlHelper.GetAttributeValue(n, "key", newMD.Key); newMD.Value = XmlHelper.GetAttributeValue(n, "value", newMD.Value); entity.EntityMetadata.Add(newMD); } } }
public FieldValueKey(int id, FieldMetadata field) { _id = id; _field = field; }
public virtual void AddIndexEntry(FieldMetadata fieldMetadata, object obj) { if (!_currentBuffer.HasParent()) { var indexEntry = (obj == _currentMarshalledObject) ? _currentIndexEntry : obj; if (_isNew || !UpdateDepth().CanSkip(_reference)) { fieldMetadata.AddIndexEntry(Transaction(), ObjectID(), indexEntry); } return; } _currentBuffer.RequestIndexEntry(fieldMetadata); }
internal virtual void UseField(QField a_field) { Read(); if (_bytes == null) { _fieldMetadata = null; return; } ReadClassMetadata(); _member = null; if (a_field == null) { _fieldMetadata = null; return; } if (_classMetadata == null) { _fieldMetadata = null; return; } _fieldMetadata = FieldMetadataFrom(a_field, _classMetadata); if (_fieldMetadata == null) { FieldNotFound(); return; } var handlerVersion = _classMetadata.SeekToField(Transaction(), _bytes, _fieldMetadata); if (handlerVersion == HandlerVersion.Invalid) { FieldNotFound(); return; } _handlerVersion = handlerVersion._number; }
private object ReadFieldValue(ClassMetadata classMetadata, FieldMetadata field) { if (!classMetadata.SeekToField(this, field)) { return null; } return field.Read(this); }
private object GetFieldValue(int id, FieldMetadata field) { var key = new FieldValueKey(id, field); var cachedValue = _fieldValueCache[key]; if (null != cachedValue) { return cachedValue; } var fieldValue = ReadFieldValue(id, field); _fieldValueCache[key] = fieldValue; return fieldValue; }
private bool HasBTreeIndex(FieldMetadata field) { return !field.IsVirtual(); }
private bool IsTyped(FieldMetadata field) { return !Handlers4.IsUntyped(field.GetHandler()); }