public Search(Dictionary<string, string> searchTerms, System.Type type, FormStorage<bool> storage)
{
_searchTerms = searchTerms;
_storage = storage;
_searchList = new BindingList<string>();
InitializeComponent();
List<string> list = type.GetProperties().Select(p => p.Name).ToList();
this.comboCriteria.DataSource = type.GetProperties().Select(p => p.Name).ToList();
this.listSearchTerms.DataSource = _searchList;
this.buttonRemove.Enabled = false;
}
public static IEnumerable<DeclaredPersistentProperty> PersistentInfo(System.Type @class, IEnumerable<Property> properties, bool includeEmbedded)
{
// a persistent property can be anything including a noop "property" declared in the mapping
// for query only. In this case I will apply some trick to get the MemberInfo.
var candidateMembers =
@class.GetFields(DefaultBindingFlags).Concat(@class.GetProperties(DefaultBindingFlags).Cast<MemberInfo>()).ToList();
var candidateMembersNames = candidateMembers.Select(m => m.Name).ToList();
foreach (var property in properties)
{
if(includeEmbedded && property.PropertyAccessorName=="embedded")
yield return new DeclaredPersistentProperty(property, DeclaredPersistentProperty.NotAvailableMemberInfo);
var exactMemberIdx = candidateMembersNames.IndexOf(property.Name);
if (exactMemberIdx >= 0)
{
// No metter which is the accessor the audit-attribute should be in the property where available and not
// to the member used to read-write the value. (This method work even for access="field").
yield return new DeclaredPersistentProperty(property, candidateMembers[exactMemberIdx]);
}
else
{
// try to find the field using field-name-strategy
//
// This part will run for:
// 1) query only property (access="none" or access="noop")
// 2) a strange case where the element <property> is declared with a "field.xyz" but only a field is used in the class. (Only God may know way)
var exactFieldIdx = GetMemberIdxByFieldNamingStrategies(candidateMembersNames, property);
if (exactFieldIdx >= 0)
{
yield return new DeclaredPersistentProperty(property, candidateMembers[exactFieldIdx]);
}
}
}
}
private static List<PropertyInfo> GetInterfaceProperties(System.Type interfaceToReflect, List<PropertyInfo> properties)
{
var interfaces = interfaceToReflect.GetInterfaces();
foreach (var inter in interfaces)
{
properties.AddRange(GetInterfaceProperties(inter, properties));
}
properties.AddRange(interfaceToReflect.GetProperties(BindingFlags.Public | BindingFlags.Instance).ToList());
return properties.Distinct().OrderBy(i => i.Name).ToList();
}
private void searchForRevisionInfoCfgInProperties(System.Type t, ref bool revisionNumberFound,
ref bool revisionTimestampFound, String accessType) {
foreach (PropertyInfo property in t.GetProperties()) {
//RevisionNumber revisionNumber = property.getAnnotation(RevisionNumber.class);
RevisionNumberAttribute revisionNumber = (RevisionNumberAttribute)Attribute.GetCustomAttribute(property, typeof(RevisionNumberAttribute));
RevisionTimestampAttribute revisionTimestamp = (RevisionTimestampAttribute)Attribute.GetCustomAttribute(property, typeof(RevisionTimestampAttribute));
if (revisionNumber != null) {
if (revisionNumberFound) {
throw new MappingException("Only one property may have the attribute [RevisionNumber]!");
}
System.Type revNrType = property.PropertyType;
if (revNrType.Equals( typeof(int)) || revNrType.Equals( typeof(Int16)) || revNrType.Equals( typeof(Int32)) || revNrType.Equals( typeof(Int64))) {
revisionInfoIdData = new PropertyData(property.Name, property.Name, accessType, ModificationStore._NULL);
revisionNumberFound = true;
} else if (revNrType.Equals(typeof(long))) {
revisionInfoIdData = new PropertyData(property.Name, property.Name, accessType, ModificationStore._NULL);
revisionNumberFound = true;
// The default is integer
revisionPropType = "long";
} else {
throw new MappingException("The field decorated with [RevisionNumberAttribute] must be of type " +
"int, Int16, Int32, Int64 or long");
}
// Getting the @Column definition of the revision number property, to later use that info to
// generate the same mapping for the relation from an audit table's revision number to the
// revision entity revision number.
ColumnAttribute revisionPropColumn = (ColumnAttribute)Attribute.GetCustomAttribute(property,typeof(ColumnAttribute));
if (revisionPropColumn != null) {
revisionPropSqlType = revisionPropColumn.columnDefinition;
}
}
if (revisionTimestamp != null) {
if (revisionTimestampFound) {
throw new MappingException("Only one property may be decorated with [RevisionTimestampAttribute]!");
}
System.Type revisionTimestampType = property.GetType();
if (typeof(DateTime).Equals(revisionTimestampType)) {
revisionInfoTimestampData = new PropertyData(property.Name, property.Name, accessType, ModificationStore._NULL);
revisionTimestampFound = true;
} else {
throw new MappingException("The field decorated with @RevisionTimestamp must be of type DateTime");
}
}
}
}
private void AddPropertiesFromClass(System.Type clazz) {
//No need to go to base class, the .NET GetProperty method can bring the base properties also
//System.Type superclazz = clazz.BaseType;
//if (!"System.Object".Equals(superclazz.FullName))
//{
// AddPropertiesFromClass(superclazz);
//}
//ORIG: addFromProperties(clazz.getDeclaredProperties("field"), "field", fieldAccessedPersistentProperties);
//addFromProperties(clazz.getDeclaredProperties("property"), "property", _propertyAccessedPersistentProperties);
//only one call is needed, .NET does not differentiate between field and property
//AddFromProperties(clazz.GetProperties(BindingFlags.GetField), "field", _fieldAccessedPersistentProperties);
AddFromProperties(clazz.GetProperties(), "property", _propertyAccessedPersistentProperties);
}
public EntityBuilder(System.Type type)
{
if (type == null)
throw new ArgumentNullException("type");
Type = type;
Accessor = TypeAccessor.Create(type);
Properties = new Dictionary<string, PropertyInfo>();
foreach (var property in type.GetProperties())
{
Properties[property.Name] = property;
}
}
protected override IList<Newtonsoft.Json.Serialization.JsonProperty> CreateProperties(System.Type type, MemberSerialization memberSerialization)
{
var props = type.GetProperties(System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance);
List<Newtonsoft.Json.Serialization.JsonProperty> jsonProps = new List<Newtonsoft.Json.Serialization.JsonProperty>();
foreach (var prop in props)
{
jsonProps.Add(base.CreateProperty(prop, memberSerialization));
}
foreach (var field in type.GetFields(System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance))
{
jsonProps.Add(base.CreateProperty(field, memberSerialization));
}
jsonProps.ForEach(p => { p.Writable = true; p.Readable = true; });
return jsonProps;
}
/// <summary>
/// Configures the display of the list view control based upon the attributes exposed by the object
/// </summary>
/// <param name="ObjType"></param>
public void SetDisplayType(System.Type ObjType)
{
List<string> ColumnList = new List<String>();
PropertyInfo[] Properties = ObjType.GetProperties();
List<PropertyInfo> listPropInfoForColumn = new List<PropertyInfo>();
foreach(PropertyInfo Property in Properties)
{
ColumnAttribute[] Attributes = Property.GetCustomAttributes(typeof(ColumnAttribute), true) as ColumnAttribute[];
foreach (ColumnAttribute Attrib in Attributes)
{
ColumnList.Add(Attrib.ColumnName);
listPropInfoForColumn.Add(Property);
}
if (Property.GetCustomAttributes(typeof(ThisToOneRelationAttribute), true).Length > 0)
{
ColumnList.Add(Property.Name);
listPropInfoForColumn.Add(Property);
}
}
Trace.WriteLineIf(ColumnList.Count == 0, "No columns defined for type: " + ObjType.ToString(), "UI");
this.BeginUpdate();
this.Items.Clear();
this.Columns.Clear();
this.Columns.Add("Name", 150, HorizontalAlignment.Left);
foreach(string ColumnName in ColumnList)
{
this.Columns.Add(ColumnName, _ColumnDefaultWidth, HorizontalAlignment.Left);
}
this.EndUpdate();
this.ColumnProperties = listPropInfoForColumn.ToArray();
/*
this.ColumnProperties = new PropertyInfo[ColumnList.Count];
for(int iColumn = 0; iColumn < ColumnList.Count; iColumn++)
{
ColumnHeader Column = this.Columns[iColumn + 1];
ColumnProperties[iColumn] = ObjType.GetProperty(listPropInfoForColumn[iColumn].Name);
Debug.Assert(ColumnProperties[iColumn] != null);
}
*/
LoadColumnVisibilitySettings();
}
private void CreateControlContentForSingleEntry (CVM.TableLayoutDefinition ContentInstance,
System.Type ContentClass, Grid Parent)
{
Parent.Children.Clear ();
Parent.RowDefinitions.Clear ();
Parent.ColumnDefinitions.Clear ();
PropertyInfo [] Properties = ContentClass.GetProperties ();
GridLengthConverter GLConverter = new GridLengthConverter ();
int RowIndex = 0;
foreach (PropertyInfo PropInfo in Properties)
{
String LabePropertyName = PropInfo.Name;
String OptionStringName = LabePropertyName + "_Option";
FieldInfo OptionField = (FieldInfo)ContentClass.GetField (OptionStringName);
String Options;
if (OptionField != null)
{
Options = (String)OptionField.GetValue (ContentInstance);
if (Options.IndexOf ("NoUpdate") != -1)
continue;
}
String HelpStringName = LabePropertyName + "_Help";
FieldInfo HelpField = (FieldInfo) ContentClass.GetField (HelpStringName);
RowDefinition MainRow = new RowDefinition ();
Parent.RowDefinitions.Add (MainRow);
Grid SubGrid = new Grid ();
Parent.Children.Add (SubGrid);
Grid.SetRow (SubGrid, RowIndex++);
Grid.SetColumn (SubGrid, 0);
Label PropertyNameLabel = new Label ();
PropertyNameLabel.Content = LabePropertyName;
SubGrid.Children.Add (PropertyNameLabel);
Grid.SetRow (PropertyNameLabel, 0);
SubGrid.ColumnDefinitions.Add (new ColumnDefinition ());
SubGrid.ColumnDefinitions [0].Width = (GridLength)GLConverter.ConvertFromString ("6" + "*");
SubGrid.ColumnDefinitions.Add (new ColumnDefinition ());
SubGrid.ColumnDefinitions [1].Width = (GridLength)GLConverter.ConvertFromString ("8" + "*");
SubGrid.RowDefinitions.Add (new RowDefinition ());
SubGrid.RowDefinitions [0].Height = (GridLength)GLConverter.ConvertFromString ("*");
if (PropInfo.PropertyType == typeof (int))
{
TextBox ContentBox = CreateSimpleLine (ContentInstance, PropInfo, MainRow, SubGrid, HelpField);
}
if (PropInfo.PropertyType == typeof (double))
{
TextBox ContentBox = CreateSimpleLine (ContentInstance, PropInfo, MainRow, SubGrid, HelpField);
}
if (PropInfo.PropertyType == typeof (Size))
{
TextBox [] ContentBoxes = CreateTwoSubLines (ContentInstance, PropInfo, MainRow, SubGrid,
new String [] { "Weite", "Höhe" }, HelpField);
}
if (PropInfo.PropertyType == typeof (Point))
{
TextBox [] ContentBoxes = CreateTwoSubLines (ContentInstance, PropInfo, MainRow, SubGrid,
new String [] { "Links", "Oben" }, HelpField);
}
if (PropInfo.PropertyType == typeof (String))
{
TextBox ContentBox = CreateSimpleLine (ContentInstance, PropInfo, MainRow, SubGrid, HelpField);
}
if (PropInfo.PropertyType == typeof (bool))
{
RadioButton [] Buttons = CreateBoolLine (ContentInstance, PropInfo, MainRow, SubGrid,
new String [] { "Ja", "Nein" }, HelpField);
}
}
}
private static PropertyInfo GetTypedIndexer(System.Type type)
{
if ((!typeof(IList).IsAssignableFrom(type) && !typeof(ITypedList).IsAssignableFrom(type)) && !typeof(IListSource).IsAssignableFrom(type))
{
return null;
}
PropertyInfo info = null;
PropertyInfo[] properties = type.GetProperties(BindingFlags.Public | BindingFlags.Instance);
for (int i = 0; i < properties.Length; i++)
{
if ((properties[i].GetIndexParameters().Length > 0) && (properties[i].PropertyType != typeof(object)))
{
info = properties[i];
if (info.Name == "Item")
{
return info;
}
}
}
return info;
}
private void ListProperties(System.Type objType)
{
Document doc = Application.DocumentManager.MdiActiveDocument;
Editor ed = doc.Editor;
ed.WriteMessage("\nReadable Properties for: " + objType.Name + " : ");
PropertyInfo[] propInfos = objType.GetProperties();
foreach (PropertyInfo propInfo in propInfos)
{
if (propInfo.CanRead)
{
ed.WriteMessage("\n " + propInfo.Name + " : " + propInfo.PropertyType);
}
}
ed.WriteMessage(System.Environment.NewLine); // "\n";
}
private void BindClass(System.Type entity, PersistentClass pclass)
{
pclass.IsLazy = true;
pclass.EntityName = entity.FullName;
pclass.ClassName = entity.AssemblyQualifiedName;
pclass.ProxyInterfaceName = entity.AssemblyQualifiedName;
string tableName = GetClassTableName(pclass);
Table table = mappings.AddTable(null, null, tableName, null, pclass.IsAbstract.GetValueOrDefault(), null);
((ITableOwner) pclass).Table = table;
pclass.IsMutable = true;
PropertyInfo[] propInfos = entity.GetProperties();
PropertyInfo toExclude = new IdBinder(this, propInfos).Bind(pclass, table);
pclass.CreatePrimaryKey(dialect);
BindProperties(pclass, propInfos.Where(x => x != toExclude));
mappings.AddClass(pclass);
string qualifiedName = pclass.MappedClass == null ? pclass.EntityName : pclass.MappedClass.AssemblyQualifiedName;
mappings.AddImport(qualifiedName, pclass.EntityName);
if (mappings.IsAutoImport && pclass.EntityName.IndexOf('.') > 0) {
mappings.AddImport(qualifiedName, StringHelper.Unqualify(pclass.EntityName));
}
}
/// <summary>
/// Resolves mapping type in target type without caching and returning with Exception
/// if Mapping does not exists
/// </summary>
/// <param name="aTarget">
/// Object type to resolve property from <see cref="System.Type"/>
/// </param>
/// <param name="aMapping">
/// Property name <see cref="System.String"/>
/// </param>
/// <param name="aThrowException">
/// Set true if throwing exception on non success is needed <see cref="System.Boolean"/>
/// </param>
/// <returns>
/// Property info if successful, null if not <see cref="PropertyInfo"/>
/// </returns>
public static PropertyInfo ResolveMappingPropertyByType (System.Type aTarget, string aMapping, bool aThrowException)
{
if ((aMapping == "") || (aTarget == null))
return (null);
/* if (TypeValidator.IsCompatible(aTarget, TypeValidator.typeIVirtualObject) == true)
throw new Exception ("Searching property by type for VirtualObject is not possible! Check and correct implementation!");*/
foreach (PropertyInfo pInfo in aTarget.GetProperties ())
if (pInfo.Name == aMapping)
return (pInfo);
if (aThrowException == true)
throw new ExceptionPropertyNotFound (aMapping);
return (null);
}
private static void RemoveDeletedProperties(List<CustomProperty> propCollection, System.Type customActivityType, IServiceProvider serviceProvider)
{
IMemberCreationService service = serviceProvider.GetService(typeof(IMemberCreationService)) as IMemberCreationService;
if (service == null)
{
throw new Exception(SR.GetString("General_MissingService", new object[] { typeof(IMemberCreationService).FullName }));
}
foreach (PropertyInfo info in customActivityType.GetProperties(BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly))
{
bool flag = false;
foreach (CustomProperty property in propCollection)
{
if ((info.Name == property.oldPropertyName) && (info.PropertyType.FullName == property.oldPropertyType))
{
flag = true;
break;
}
}
if (!flag)
{
service.RemoveProperty(customActivityType.FullName, info.Name, info.PropertyType);
}
}
foreach (EventInfo info2 in customActivityType.GetEvents(BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly))
{
bool flag2 = false;
foreach (CustomProperty property2 in propCollection)
{
if ((info2.Name == property2.oldPropertyName) && (info2.EventHandlerType.FullName == property2.oldPropertyType))
{
flag2 = true;
break;
}
}
if ((!flag2 && (info2.Name != null)) && (info2.EventHandlerType != null))
{
service.RemoveEvent(customActivityType.FullName, info2.Name, info2.EventHandlerType);
}
}
}
protected bool MatchComponentPattern(System.Type subject)
{
const BindingFlags flattenHierarchyMembers =
BindingFlags.FlattenHierarchy | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance;
if (declaredModel.IsEntity(subject))
{
return false;
}
var modelInspector = (IModelInspector) this;
return !subject.IsEnum && (subject.Namespace == null || !subject.Namespace.StartsWith("System")) /* hack */
&& !modelInspector.IsEntity(subject)
&& !subject.GetProperties(flattenHierarchyMembers).Cast<MemberInfo>().Concat(
subject.GetFields(flattenHierarchyMembers)).Any(m => modelInspector.IsPersistentId(m));
}
private IEnumerable<PropertyInfo> GetTypeProperties(System.Type type)
{
IEnumerable<PropertyInfo> props;
if (!_typePropertyCache.TryGetValue(type, out props))
{
props = type.GetProperties()
.Where(p => p.GetSetMethod() != null);
_typePropertyCache.Add(type, props);
}
return props;
}
static void AddProperties (GType gtype, System.Type t)
{
uint idx = 1;
bool handlers_overridden = false;
foreach (PropertyInfo pinfo in t.GetProperties (BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly)) {
foreach (object attr in pinfo.GetCustomAttributes (typeof (PropertyAttribute), false)) {
if(pinfo.GetIndexParameters().Length > 0)
throw(new InvalidOperationException(String.Format("GLib.RegisterPropertyAttribute cannot be applied to property {0} of type {1} because the property expects one or more indexed parameters", pinfo.Name, t.FullName)));
PropertyAttribute property_attr = attr as PropertyAttribute;
if (!handlers_overridden) {
gtksharp_override_property_handlers (gtype.Val, GetPropertyHandler, SetPropertyHandler);
handlers_overridden = true;
}
IntPtr native_name = GLib.Marshaller.StringToPtrGStrdup (property_attr.Name);
IntPtr native_nick = GLib.Marshaller.StringToPtrGStrdup (property_attr.Nickname);
IntPtr native_blurb = GLib.Marshaller.StringToPtrGStrdup (property_attr.Blurb);
IntPtr param_spec = gtksharp_register_property (gtype.Val, native_name, native_nick, native_blurb, idx, ((GType) pinfo.PropertyType).Val, pinfo.CanRead, pinfo.CanWrite);
GLib.Marshaller.Free (native_name);
GLib.Marshaller.Free (native_nick);
GLib.Marshaller.Free (native_blurb);
if (param_spec == IntPtr.Zero)
// The GType of the property is not supported
throw new InvalidOperationException (String.Format ("GLib.PropertyAttribute cannot be applied to property {0} of type {1} because the return type of the property is not supported", pinfo.Name, t.FullName));
Properties.Add (param_spec, pinfo);
idx++;
}
}
}
private object InternalParseParam(System.Type type, object data)
{
if (data == null)
return (object) null;
IList list;
if ((list = data as IList) != null)
{
if (!type.IsArray)
throw new InvalidOperationException("Not an array " + type.FullName);
System.Type elementType = type.GetElementType();
ArrayList arrayList = new ArrayList();
for (int index = 0; index < list.Count; ++index)
{
object obj = this.InternalParseParam(elementType, list[index]);
arrayList.Add(obj);
}
return (object) arrayList.ToArray(elementType);
}
IDictionary dictionary;
if ((dictionary = data as IDictionary) != null)
{
if (!type.IsClass)
throw new InvalidOperationException("Not a class " + type.FullName);
ConstructorInfo constructor = type.GetConstructor(BindingFlags.Instance | BindingFlags.Public, (Binder) null, CallingConventions.Any, new System.Type[0], (ParameterModifier[]) null);
if (constructor == null)
throw new InvalidOperationException("Cannot find a default constructor for " + type.FullName);
object obj1 = constructor.Invoke(new object[0]);
using (List<System.Reflection.FieldInfo>.Enumerator enumerator = ((IEnumerable<System.Reflection.FieldInfo>) type.GetFields(BindingFlags.Instance | BindingFlags.Public)).ToList<System.Reflection.FieldInfo>().GetEnumerator())
{
while (enumerator.MoveNext())
{
System.Reflection.FieldInfo current = enumerator.Current;
try
{
object obj2 = this.InternalParseParam(current.FieldType, dictionary[(object) current.Name]);
current.SetValue(obj1, obj2);
}
catch (KeyNotFoundException ex)
{
}
}
}
using (List<PropertyInfo>.Enumerator enumerator = ((IEnumerable<PropertyInfo>) type.GetProperties(BindingFlags.Instance | BindingFlags.Public)).ToList<PropertyInfo>().GetEnumerator())
{
while (enumerator.MoveNext())
{
PropertyInfo current = enumerator.Current;
try
{
object obj2 = this.InternalParseParam(current.PropertyType, dictionary[(object) current.Name]);
MethodInfo setMethod = current.GetSetMethod();
if (setMethod != null)
setMethod.Invoke(obj1, new object[1]{ obj2 });
}
catch (KeyNotFoundException ex)
{
}
catch (TargetInvocationException ex)
{
}
}
}
return Convert.ChangeType(obj1, type);
}
string str;
if ((str = data as string) != null)
return (object) str;
if (data is bool)
return (object) (bool) data;
if (data is double)
return (object) (double) data;
if (data is int || data is short || (data is int || data is long) || data is long)
return Convert.ChangeType(data, type);
throw new InvalidOperationException("Cannot parse " + Json.Serialize(data));
}
/// <summary>
/// Gets the best matching property info for the given name on the given type if the same property is defined on
/// multiple levels in the object hierarchy.
/// </summary>
private static PropertyInfo GetBestMatchingProperty(string propertyName, System.Type type)
{
PropertyInfo[] propertyInfos = type.GetProperties(BindingFlags.Public | BindingFlags.Instance | BindingFlags.FlattenHierarchy);
PropertyInfo bestMatch = null;
int bestMatchDistance = int.MaxValue;
for (int i = 0; i < propertyInfos.Length; i++)
{
PropertyInfo info = propertyInfos[i];
if (info.Name == propertyName)
{
int distance = CalculateDistance(type, info.DeclaringType);
if (distance == 0)
{
// as close as we're gonna get...
return info;
}
if (distance > 0 && distance < bestMatchDistance)
{
bestMatch = info;
bestMatchDistance = distance;
}
}
}
return bestMatch;
}
static void AddProperties(GType gtype, System.Type t, bool register_instance_prop, ref bool handlers_overridden)
{
if (register_instance_prop) {
IntPtr declaring_class = gtype.GetClassPtr ();
ParamSpec pspec = new ParamSpec ("gtk-sharp-managed-instance", "", "", GType.Pointer, ParamFlags.Writable | ParamFlags.ConstructOnly);
g_object_class_install_property (declaring_class, idx, pspec.Handle);
idx++;
}
foreach (PropertyInfo pinfo in t.GetProperties (BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly)) {
foreach (object attr in pinfo.GetCustomAttributes (typeof (PropertyAttribute), false)) {
if(pinfo.GetIndexParameters().Length > 0)
throw(new InvalidOperationException(String.Format("GLib.RegisterPropertyAttribute cannot be applied to property {0} of type {1} because the property expects one or more indexed parameters", pinfo.Name, t.FullName)));
if (!handlers_overridden) {
IntPtr class_ptr = gtype.GetClassPtr ();
GObjectClass gobject_class = (GObjectClass) Marshal.PtrToStructure (class_ptr, typeof (GObjectClass));
gobject_class.get_prop_cb = GetPropertyHandler;
gobject_class.set_prop_cb = SetPropertyHandler;
Marshal.StructureToPtr (gobject_class, class_ptr, false);
handlers_overridden = true;
}
PropertyAttribute property_attr = attr as PropertyAttribute;
try {
IntPtr param_spec = RegisterProperty (gtype, property_attr.Name, property_attr.Nickname, property_attr.Blurb, idx, (GType) pinfo.PropertyType, pinfo.CanRead, pinfo.CanWrite);
Properties.Add (param_spec, pinfo);
idx++;
} catch (ArgumentException) {
throw new InvalidOperationException (String.Format ("GLib.PropertyAttribute cannot be applied to property {0} of type {1} because the return type of the property is not supported", pinfo.Name, t.FullName));
}
}
}
}
private static object[] GetConstants(System.Type enumType)
{
MethodAttributes attributes = MethodAttributes.Static | MethodAttributes.Public;
PropertyInfo[] properties = enumType.GetProperties();
ArrayList list = new ArrayList();
for (int i = 0; i < properties.Length; i++)
{
PropertyInfo info = properties[i];
if (info.PropertyType == typeof(Color))
{
MethodInfo getMethod = info.GetGetMethod();
if ((getMethod != null) && ((getMethod.Attributes & attributes) == attributes))
{
object[] index = null;
list.Add(info.GetValue(null, index));
}
}
}
return list.ToArray();
}
private static StructureType ExploreClass(System.Type type)
{
StructureType ddsType = new StructureTypeImpl();
TypeProperty typeProp = new TypePropertyImpl();
typeProp.SetName(type.FullName);
typeProp.SetTypeId(type.GetHashCode());
TypeFlag flag = default(TypeFlag);
flag |= (type.IsSealed ? TypeFlag.IS_FINAL : 0);
typeProp.SetFlag(flag);
ddsType.SetProperty(typeProp);
List<Member> listMember = new List<Member>();
var fields = type.GetFields(BindingFlags.Public |
BindingFlags.Instance);
uint lastId = 0;
foreach (var member in fields)
{
Member memberInfo = new MemberImpl();
NonFieldAttribute isField = member.GetCustomAttribute<NonFieldAttribute>();
if (isField != null)
continue;
MemberProperty memberProp = new MemberPropertyImpl();
memberProp.SetName(member.Name);
IDAttribute id = member.GetCustomAttribute<IDAttribute>();
if (id != null)
{
memberProp.SetMemberId(id.Value);
lastId = id.Value;
}
else
{
lastId++;
memberProp.SetMemberId(lastId);
}
MemberFlag memberFlag = default(MemberFlag);
KeyAttribute isKey = member.GetCustomAttribute<KeyAttribute>();
if (isKey != null)
{
memberFlag |= MemberFlag.IS_KEY;
}
OptionalAttribute isOptional = member.GetCustomAttribute<OptionalAttribute>();
if (isOptional != null)
{
memberFlag |= MemberFlag.IS_OPTIONAL;
}
memberProp.SetFlag(memberFlag);
memberProp.IsProperty = false;
memberInfo.SetProperty(memberProp);
listMember.Add(memberInfo);
}
var props = type.GetProperties(BindingFlags.Public |
BindingFlags.Instance);
foreach (var member in props)
{
Member memberInfo = new MemberImpl();
NonFieldAttribute isField = member.GetCustomAttribute<NonFieldAttribute>();
if (isField != null)
continue;
MemberProperty memberProp = new MemberPropertyImpl();
memberProp.SetName(member.Name);
IDAttribute id = member.GetCustomAttribute<IDAttribute>();
if (id != null)
{
memberProp.SetMemberId(id.Value);
lastId = id.Value;
}
else
{
continue; // TODO. Check if only process process members with ID
//lastId++;
//memberProp.SetMemberId(lastId);
}
MemberFlag memberFlag = default(MemberFlag);
KeyAttribute isKey = member.GetCustomAttribute<KeyAttribute>();
if (isKey != null)
{
memberFlag |= MemberFlag.IS_KEY;
}
OptionalAttribute isOptional = member.GetCustomAttribute<OptionalAttribute>();
if (isOptional != null)
{
memberFlag |= MemberFlag.IS_OPTIONAL;
}
memberProp.SetFlag(memberFlag);
memberProp.IsProperty = true;
memberInfo.SetProperty(memberProp);
listMember.Add(memberInfo);
}
ddsType.SetMember(listMember);
return ddsType;
}
protected bool MatchEntity(System.Type subject)
{
const BindingFlags flattenHierarchyMembers =
BindingFlags.FlattenHierarchy | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance;
if(declaredModel.Components.Contains(subject))
{
return false;
}
var modelInspector = (IModelInspector) this;
return subject.IsClass &&
subject.GetProperties(flattenHierarchyMembers).Cast<MemberInfo>().Concat(subject.GetFields(flattenHierarchyMembers)).Any(m => modelInspector.IsPersistentId(m));
}
private ArrayList GetList(ManagementScope scope, System.Type t, string q)
{
ArrayList items = new ArrayList();
ManagementObjectSearcher srch = new ManagementObjectSearcher(scope, new ObjectQuery(q));
foreach (ManagementObject i in srch.Get())
{
object n = Activator.CreateInstance(t, true);
foreach(PropertyInfo tp in t.GetProperties())
{
if (tp.CanWrite)
{
PropertyData p = (from PropertyData x in i.Properties
where x.Name.ToLower() == tp.Name.ToLower()
select x).FirstOrDefault();
if(p != null)
{
object v = p.Value;
if (v != null)
tp.SetValue(n, v, null);
}
}
}
items.Add(n);
}
return items;
}
public UserDefinedTypeImporter(System.Type realType)
{
RealType = realType;
RealTypeName = UserDefinedTypeSupport.GetTypeName(realType);
var fields = realType.GetFields();
var properties = realType.GetProperties();
FieldSetters = new System.Collections.Generic.Dictionary<string, SetterDelegate>(fields.Length + properties.Length + 1);
FieldSetters["__Type"] = this.CheckType;
foreach (var field in UserDefinedTypeSupport.GetFields(RealType))
{
FieldSetters[field.Name] = CreateFieldSetter(realType, field.Member);
}
foreach (var property in UserDefinedTypeSupport.GetProperties(RealType))
{
FieldSetters[property.Name] = CreatePropertySetter(realType, property.Member);
}
}
/// <summary>
/// Declare a new struct type in the current scope based on an actual class.
/// </summary>
/// <remarks>
/// Used to declare predefined struct types representing existing classes in metamodel.
/// </remarks>
/// <param name="type">The class type.</param>
private void Process_ModelStruct(System.Type type)
{
if (NameContext.Current.Scope.Model.Instances.OfType<Type>().Count(t => t.UnderlyingType == type) == 0)
{
StructType structType = new StructType();
// Namespace
structType.Namespace = (Namespace)NameContext.Current.Scope;
// Name
structType.Name = AttributeHelpers.GetTypeName(type);
// Underlying type
structType.UnderlyingType = type;
// Hidden
structType.AddMetaInfo(new HiddenInfo());
// Enter scope
using (new NameContextScope(structType))
{
// Fields
foreach (PropertyInfo property in type.GetProperties(BindingFlags.Instance | BindingFlags.Public))
{
StructField structField = new StructField();
structField.Name = AttributeHelpers.GetMemberName(property);
structField.Type = BuiltInType.GetBuiltInType(property.PropertyType);
structField.Struct = structType;
// Hidden
structField.AddMetaInfo(new HiddenInfo());
}
}
}
}
private PropertyInfo[] GetProperties(System.Type type)
{
List<PropertyInfo> list = new List<PropertyInfo>();
list.AddRange(type.GetProperties(BindingFlags.FlattenHierarchy | BindingFlags.Public | BindingFlags.Static | BindingFlags.Instance));
if (type.IsInterface)
{
foreach (System.Type type2 in type.GetInterfaces())
{
list.AddRange(type2.GetProperties(BindingFlags.FlattenHierarchy | BindingFlags.Public | BindingFlags.Instance));
}
}
return list.ToArray();
}
private static System.Reflection.PropertyInfo[] getAccessibleProperties(System.Type clazz) {
System.Reflection.PropertyInfo[] properties = clazz.GetProperties();
//TODO
return properties;
/*
* Short circuit for the (hopefully) majority of cases where the
* clazz is public
*/
if (clazz.IsPublic) {
return properties;
}
/*
* No luck - the class is not public, so we're going the longer way.
*/
properties = new System.Reflection.PropertyInfo[0];
return properties;
// TODO
// MethodInfo[] methodInfos = new MethodInfo[methods.Length];
//
// for (int i = methods.Length; i-- > 0; ) {
// methodInfos[i] = new MethodInfo(methods[i]);
// }
//
// int upcastCount = getAccessibleMethods(clazz, methodInfos, 0);
//
// /*
// * Reallocate array in case some method had no accessible counterpart.
// */
//
// if (upcastCount < methods.Length) {
// methods = new System.Reflection.MethodInfo[upcastCount];
// }
//
// int j = 0;
// for (int i = 0; i < methodInfos.Length; ++i) {
// MethodInfo methodInfo = methodInfos[i];
// if (methodInfo.upcast) {
// methods[j++] = methodInfo.method;
// }
// }
// return methods;
}
private List<PropertyInfo> GetGraphicProperties(System.Type type)
{
List<PropertyInfo> graphicProperties = new List<PropertyInfo>();
PropertyInfo[] properties = type.GetProperties();
foreach (var item in properties)
{
//Check if we have a data provider for this property type.
IGraphicDataProvider provider = GraphicDataProvider.GetGraphicDataProviderForType(item.PropertyType);
if (null != provider)
graphicProperties.Add(item);
}
return graphicProperties;
}
public static void DisposProperties(System.Type type, Dictionary<string, ClassMethodInfo> cmfDict)
{
PropertyInfo[] array = type.GetProperties(BindingFlags | BindingFlags.GetProperty | BindingFlags.SetProperty | BindingFlags.Instance | BindingFlags.FlattenHierarchy);
foreach(PropertyInfo info in array){
string key = type.Namespace + "." + type.Name + "." + info.Name;
ClassMethodInfo cmf = !cmfDict.ContainsKey(key) ? new ClassMethodInfo() : cmfDict[key];
cmf.fullName = key;
cmf.className = type.Name;
cmf.name = info.Name;
cmf.returnName = info.PropertyType.Name;
cmf.isStatic = false;
cmf.isCanRead = info.CanRead;
cmf.isCanWrite = info.CanRead;
cmf.isPf = true;
cmfDict[key] = cmf;
}
}