/// <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;
}
/// <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;
}
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;
}
private void AddField(FieldMetadata fieldMetadata)
{
this.Tags = EventFieldTags.None;
this.bufferedArrayFieldCount++;
this.impl.fields.Add(fieldMetadata);
if (this.currentGroup != null)
{
this.currentGroup.IncrementStructFieldCount();
}
}
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());
}
