public static object deserializedField(FieldInfo prop, string value)
{
if (string.IsNullOrEmpty(value))
return null;
Type proptype = prop.FieldType;
if (proptype.IsGenericType && proptype.GetGenericTypeDefinition() == typeof(List<>))
{
object objfield = proptype.GetConstructor(Type.EmptyTypes).Invoke(null);
Type listParamType = proptype.GetGenericArguments()[0];
String[] arrays = value.Split(ListSeparation);
for (int i = 0; i < arrays.Length; ++i)
{
object arr_element = Data.Converter.GetValue(listParamType, arrays[i]);
proptype.GetMethod("Add").Invoke(objfield, new object[] { arr_element });
}
return objfield;
}
else
{
return Data.Converter.GetValue(proptype, value);
}
}
public override void ApplyToFieldInfo(FieldInfo Info, ISerializablePacket Packet, Type Field)
{
if (Field.Equals(typeof(bool)))
Info.SetValue(Packet, val);
else
Info.SetValue(Packet, Convert.ChangeType((bool)val, Info.FieldType));
}
/// <summary>
/// 判断字段的过虑条件。
/// </summary>
/// <param name="field"></param>
/// <returns></returns>
public static bool ProccessField(FieldInfo field)
{
if(field.FieldType.IsSubclassOf(typeof(Delegate)))
return false;
return true;
}
public FieldGetter(FieldInfo fieldInfo)
{
_fieldInfo = fieldInfo;
Name = fieldInfo.Name;
MemberType = fieldInfo.FieldType;
_lateBoundFieldGet = LazyFactory.Create(() => DelegateFactory.CreateGet(fieldInfo));
}
static DynamicScopeTokenResolver()
{
BindingFlags s_bfInternal = BindingFlags.NonPublic | BindingFlags.Instance;
s_indexer = Type.GetType("System.Reflection.Emit.DynamicScope").GetProperty("Item", s_bfInternal);
s_scopeFi = Type.GetType("System.Reflection.Emit.DynamicILGenerator").GetField("m_scope", s_bfInternal);
s_varArgMethodType = Type.GetType("System.Reflection.Emit.VarArgMethod");
s_varargFi1 = s_varArgMethodType.GetField("m_method", s_bfInternal);
s_varargFi2 = s_varArgMethodType.GetField("m_signature", s_bfInternal);
s_genMethodInfoType = Type.GetType("System.Reflection.Emit.GenericMethodInfo");
s_genmethFi1 = s_genMethodInfoType.GetField("m_methodHandle", s_bfInternal);
s_genmethFi2 = s_genMethodInfoType.GetField("m_context", s_bfInternal);
s_genFieldInfoType = Type.GetType("System.Reflection.Emit.GenericFieldInfo", false);
if (s_genFieldInfoType != null)
{
s_genfieldFi1 = s_genFieldInfoType.GetField("m_fieldHandle", s_bfInternal);
s_genfieldFi2 = s_genFieldInfoType.GetField("m_context", s_bfInternal);
}
else
{
s_genfieldFi1 = s_genfieldFi2 = null;
}
}
// public constructor to form the custom attribute with constructor and constructor
// parameters.
public CustomAttributeBuilder(ConstructorInfo con, Object[] constructorArgs,
PropertyInfo[] namedProperties, Object[] propertyValues,
FieldInfo[] namedFields, Object[] fieldValues)
{
InitCustomAttributeBuilder(con, constructorArgs, namedProperties,
propertyValues, namedFields, fieldValues);
}
public virtual void SetUp ()
{
_associatedExpression = ExpressionHelper.CreateExpression();
_method = typeof (AnonymousType).GetMethod ("get_a");
_property = typeof (AnonymousType).GetProperty ("a");
_field = typeof (MemberBindingTestBase).GetField ("_associatedExpression", BindingFlags.Instance | BindingFlags.NonPublic);
}
private void AddModel(Type fragmentClass, FieldInfo field, InjectionAttribute injectionAttribute)
{
// bool optional = field.HasAttribute<OptionalAttribute>() || injectionAttribute.IsOptional();
// var dependencyModel = new DependencyModel(injectionAttribute, field.FieldType, fragmentClass, optional);
var injectedFieldModel = new InjectedFieldModel(field, injectionAttribute);
this.fields.Add(injectedFieldModel);
}
/// <summary>
/// Find the UIPartActionWindow for a part. Usually this is useful just to mark it as dirty.
/// </summary>
public static UIPartActionWindow FindActionWindow(this Part part)
{
if (part == null)
return null;
// We need to do quite a bit of piss-farting about with reflection to
// dig the thing out. We could just use Object.Find, but that requires hitting a heap more objects.
UIPartActionController controller = UIPartActionController.Instance;
if (controller == null)
return null;
if (windowListField == null)
{
Type cntrType = typeof(UIPartActionController);
foreach (FieldInfo info in cntrType.GetFields(BindingFlags.Instance | BindingFlags.NonPublic))
{
if (info.FieldType == typeof(List<UIPartActionWindow>))
{
windowListField = info;
goto foundField;
}
}
Debug.LogWarning("*PartUtils* Unable to find UIPartActionWindow list");
return null;
}
foundField:
List<UIPartActionWindow> uiPartActionWindows = (List<UIPartActionWindow>)windowListField.GetValue(controller);
if (uiPartActionWindows == null)
return null;
return uiPartActionWindows.FirstOrDefault(window => window != null && window.part == part);
}
internal static Expression CreateSetFieldExpression(Expression clone, Expression value, FieldInfo fieldInfo) {
// workaround for readonly fields: use reflection, this is a lot slower but the only way except using il directly
if (fieldInfo.IsInitOnly)
return Expression.Call(Expression.Constant(fieldInfo), _fieldInfoSetValueMethod, clone, Expression.Convert(value, TypeHelper.ObjectType));
return Expression.Assign(Expression.Field(clone, fieldInfo), value);
}
public FieldGetter(FieldInfo fieldInfo)
{
_fieldInfo = fieldInfo;
_name = fieldInfo.Name;
_memberType = fieldInfo.FieldType;
_lateBoundFieldGet = DelegateFactory.CreateGet(fieldInfo);
}
private static MemberInfo[] GetSerializableMembers2(Type type)
{
// get the list of all fields
FieldInfo[] fields = type.GetFields(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
int countProper = 0;
for (int i = 0; i < fields.Length; i++)
{
if ((fields[i].Attributes & FieldAttributes.NotSerialized) == FieldAttributes.NotSerialized)
continue;
countProper++;
}
if (countProper != fields.Length)
{
FieldInfo[] properFields = new FieldInfo[countProper];
countProper = 0;
for (int i = 0; i < fields.Length; i++)
{
if ((fields[i].Attributes & FieldAttributes.NotSerialized) == FieldAttributes.NotSerialized)
continue;
properFields[countProper] = fields[i];
countProper++;
}
return properFields;
}
else
return fields;
}
internal static GenericGetter CreateGetField(Type type, FieldInfo fieldInfo)
{
DynamicMethod dynamicGet = new DynamicMethod("_", typeof(object), new Type[] { typeof(object) }, type);
ILGenerator il = dynamicGet.GetILGenerator();
if (!type.IsClass) // structs
{
var lv = il.DeclareLocal(type);
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Unbox_Any, type);
il.Emit(OpCodes.Stloc_0);
il.Emit(OpCodes.Ldloca_S, lv);
il.Emit(OpCodes.Ldfld, fieldInfo);
if (fieldInfo.FieldType.IsValueType)
il.Emit(OpCodes.Box, fieldInfo.FieldType);
}
else
{
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldfld, fieldInfo);
if (fieldInfo.FieldType.IsValueType)
il.Emit(OpCodes.Box, fieldInfo.FieldType);
}
il.Emit(OpCodes.Ret);
return (GenericGetter)dynamicGet.CreateDelegate(typeof(GenericGetter));
}
public static string CreateMessage(FieldInfo field)
{
return String.Format("Instance could not be created for field '{0}' of type '{1}' in Assembly '{2}'",
field.Name,
field.DeclaringType.FullName,
field.Module);
}
public FieldDecorator(Type forType, FieldInfo field, IProtoSerializer tail) : base(tail)
{
Helpers.DebugAssert(forType != null);
Helpers.DebugAssert(field != null);
this.forType = forType;
this.field = field;
}
public void EmitIL(ILGenerator body, FieldInfo tape, FieldInfo ptr)
{
body.Emit(OpCodes.Ldsfld, ptr);
body.Emit(OpCodes.Ldc_I4_1);
body.Emit(OpCodes.Sub);
body.Emit(OpCodes.Stsfld, ptr);
}
/// <summary>
/// Constructor
/// </summary>
public VariableField(object model, FieldInfo fieldInfo)
{
if (model == null || fieldInfo == null)
throw new Exception("Cannot create an instance of class VariableField with a null model or fieldInfo");
Object = model;
FieldInfo = fieldInfo;
}
/// <summary>
/// Dispatches the call to the extensions.
/// </summary>
/// <param name="fi">The field info reflection object.</param>
/// <param name="model">The model.</param>
public void ProcessField(FieldInfo fi, ActiveRecordModel model)
{
foreach(IModelBuilderExtension extension in extensions)
{
extension.ProcessField(fi, model);
}
}
private void GenerateEnumMemberAttributes(FieldInfo fieldInfo)
{
EnumMemberAttribute enumMemberAttr = (EnumMemberAttribute)Attribute.GetCustomAttribute(fieldInfo, typeof(EnumMemberAttribute));
if (enumMemberAttr != null)
{
this.Write("[System.Runtime.Serialization.EnumMember");
string value = enumMemberAttr.Value;
if (!string.IsNullOrEmpty(value))
{
this.Write("(Value=");
this.Write(this.ToStringHelper.ToStringWithCulture(value.ToString()));
this.Write(")\r\n");
}
this.Write("]");
}
this.GenerateAttributes(fieldInfo.GetCustomAttributes(false).Cast<Attribute>().Where(a => a.GetType() != typeof(EnumMemberAttribute)));
}
public void Visit(string settingsNamesapce, string fieldPath, FieldInfo rawSettingsField, object rawSettings)
{
// Skip 'sealed' fields.
if (rawSettingsField.IsDefined<SealedAttribute>()) return;
if (rawSettingsField.FieldType == typeof(string))
{
var originalString = (string)rawSettingsField.GetValue(rawSettings);
if (originalString != null)
{
var expandedString = ExpandVariables(originalString, _variables);
rawSettingsField.SetValue(rawSettings, expandedString);
}
}
else if (rawSettingsField.FieldType == typeof(string[]))
{
string[] arr = (string[])rawSettingsField.GetValue(rawSettings);
for (int i = 0; i < arr.Length; i++)
{
string originalString = arr[i];
if (originalString != null)
{
var expandedString = ExpandVariables(originalString, _variables);
arr[i] = expandedString;
}
}
}
}
public virtual object Decorate(FieldInfo field)
{
if (!(typeof(IWebElement).IsAssignableFrom(field.FieldType)
|| IsDecoratableList(field)))
{
return null;
}
IElementLocator locator = factory.CreateLocator(field);
if (locator == null)
{
return null;
}
if (typeof(IWebElement).IsAssignableFrom(field.FieldType))
{
return ProxyForLocator(locator);
}
else if (typeof(IList).IsAssignableFrom(field.FieldType))
{
return ProxyForListLocator(locator);
}
else
{
return null;
}
}
public RubyFieldInfo(FieldInfo/*!*/ fieldInfo, RubyMemberFlags flags, RubyModule/*!*/ declaringModule, bool isSetter, bool isDetached)
: base(flags, declaringModule) {
Assert.NotNull(fieldInfo, declaringModule);
_fieldInfo = fieldInfo;
_isSetter = isSetter;
_isDetached = isDetached;
}
private List<string> _list; //Store the list of existing languages
//[TestMethod]
//public void TestAllLanguageTranslationsExists()
//{
// Language defaultlang = new Language(); //Load the English version
// defaultlang.General.TranslatedBy = "Translated by ..."; // to avoid assertion
// foreach (String cultureName in _list) //Loop over all language files
// {
// //Load language
// var reader = new System.IO.StreamReader(Path.Combine(Configuration.BaseDirectory, "Languages") + Path.DirectorySeparatorChar + cultureName + ".xml");
// Language lang = Language.Load(reader);
// //Loop over all field in language
// checkFields(cultureName, defaultlang, lang, defaultlang.GetType().GetFields());
// checkProperty(cultureName, defaultlang, lang, defaultlang.GetType().GetProperties());
// //If u want to save a kind of fixed lang file
// //Disabled the assert fail function for it!
// // lang.Save("Languagesnew\\" + cultureName + ".xml");
// reader.Close();
// }
//}
private void checkFields(string cultureName, object completeLang, object cultureLang, FieldInfo[] fields)
{
foreach (FieldInfo fieldInfo in fields)
{
if (fieldInfo.IsPublic && fieldInfo.FieldType.Namespace.Equals("Nikse.SubtitleEdit.Logic")) {
object completeLangatt = fieldInfo.GetValue(completeLang);
object cultureLangatt = fieldInfo.GetValue(cultureLang);
if ((cultureLangatt == null) || (completeLangatt == null))
{
Assert.Fail(fieldInfo.Name + " is mssing");
}
//Console.Out.WriteLine("Field: " + fieldInfo.Name + " checked of type:" + fieldInfo.FieldType.FullName);
if (!fieldInfo.FieldType.FullName.Equals("System.String"))
{
checkFields(cultureName, completeLang, cultureLang, fieldInfo.FieldType.GetFields());
checkProperty(cultureName, completeLangatt, cultureLangatt, fieldInfo.FieldType.GetProperties());
}
else
{
Assert.Fail("no expecting a string here");
}
}
}
}
private static IGetterAndSetter Create(FieldInfo fieldInfo)
{
var setter = typeof(GetterAndSetter<,>).MakeGenericType(fieldInfo.DeclaringType, fieldInfo.FieldType);
var constructorInfo = setter.GetConstructor(new[] { typeof(FieldInfo) });
//// ReSharper disable once PossibleNullReferenceException nope, not here
return (IGetterAndSetter)constructorInfo.Invoke(new object[] { fieldInfo });
}
public void CreateProxiedMethod(FieldInfo field, MethodInfo method, TypeBuilder typeBuilder)
{
const MethodAttributes methodAttributes = MethodAttributes.Public | MethodAttributes.HideBySig |
MethodAttributes.Virtual;
ParameterInfo[] parameters = method.GetParameters();
MethodBuilder methodBuilder = typeBuilder.DefineMethod(method.Name, methodAttributes,
CallingConventions.HasThis, method.ReturnType,
parameters.Select(param => param.ParameterType).ToArray());
System.Type[] typeArgs = method.GetGenericArguments();
if (typeArgs.Length > 0)
{
var typeNames = new List<string>();
for (int index = 0; index < typeArgs.Length; index++)
{
typeNames.Add(string.Format("T{0}", index));
}
methodBuilder.DefineGenericParameters(typeNames.ToArray());
}
ILGenerator IL = methodBuilder.GetILGenerator();
Debug.Assert(MethodBodyEmitter != null);
MethodBodyEmitter.EmitMethodBody(IL, method, field);
}
/// <summary>
/// Creates a <see cref="ValueAccess"/> suitable for accessing the value in <paramref name="fieldInfo"/>.
/// </summary>
/// <param name="fieldInfo">The <see cref="FieldInfo"/></param> representing the field for which a
/// <see cref="ValueAccess"/> is required.
/// <returns>The <see cref="ValueAccess"/> that allows for accessing the value in <paramref name="fieldInfo"/>.</returns>
/// <exception cref="ArgumentNullException">when <paramref name="fieldInfo"/> is <see langword="null"/>.</exception>
public ValueAccess GetFieldValueAccess(FieldInfo fieldInfo)
{
if (null == fieldInfo)
throw new ArgumentNullException("fieldInfo");
return DoGetFieldValueAccess(fieldInfo);
}
public GlideInfo(object target, FieldInfo info)
{
Target = target;
field = info;
PropertyName = info.Name;
PropertyType = info.FieldType;
}
public static IntList GetLines(RawText rawText)
{
if (_linesField == null)
_linesField = typeof(RawText).GetField("lines", BindingFlags.NonPublic | BindingFlags.Instance);
return (IntList)_linesField.GetValue(rawText);
}
public static byte[] GetContent(RawText rawText)
{
if (_contentField == null)
_contentField = typeof(RawText).GetField("content", BindingFlags.NonPublic | BindingFlags.Instance);
return (byte[])_contentField.GetValue(rawText);
}
public void Check(FieldInfo info, Dependency parent)
{
// Dependency parent = new Dependency(info.);
bool isInterface = info.FieldType.IsInterface;
bool isAbstract = info.FieldType.IsAbstract;
bool isNotSealed = !info.FieldType.IsSealed;
string message = "";
if (isInterface)
{
message = string.Format("Field {0} is interface {1}", info.Name, info.FieldType.Name);
}
else if (isAbstract)
{
message = string.Format("Field {0} is an abstract class {1} and can be inherited from", info.Name,info.FieldType.Name);
}
else if (isNotSealed)
{
message =
string.Format("Field {0} is non sealed {1} and can be inherited from", info.Name,
info.FieldType.Name);
}
parent.Add(new Dependency(message));
// if (parent.AlreadyContains(info.FieldType))
// {
// parent.Add(new Dependency(message));
// }
// else
// {
// parent.Add(new Dependency(info.FieldType, message));
// }
}
public static string GetDescription(this Enum value)
{
Reflection.FieldInfo fieldInfo = value
.GetType()
.GetField(value.GetName());
DescriptionAttribute descriptionAttribute = fieldInfo
.GetCustomAttributes(typeof(DescriptionAttribute)
, false)
.FirstOrDefault()
as DescriptionAttribute;
return(descriptionAttribute == null?value.GetName()
: descriptionAttribute.Description);
}
private static System.Type GetType(SerializedProperty property)
{
System.Type parentType = property.serializedObject.targetObject.GetType();
System.Reflection.FieldInfo fi = parentType.GetField(property.propertyPath);
return(fi.FieldType);
}
protected override Expression VisitMemberAccess(MemberExpression m)
{
//TODO when member is declared by interface, this would solve, but need to find out implementors of interface to get backing field of property
//if (m.Expression != null && (m.Expression.NodeType == ExpressionType.Convert || m.Expression.NodeType == ExpressionType.ConvertChecked))
//{
// MemberExpression memExpr= Expression.MakeMemberAccess(((UnaryExpression)m.Expression).Operand ,m.Member) ;
// return this.VisitMemberAccess(memExpr);
//}
if (m.Expression != null && (m.Expression.NodeType == ExpressionType.Parameter || m.Expression.NodeType == ExpressionType.MemberAccess))
{
if (currentWhere == null)
{
if (m.Type == typeof(bool)) //ex: WHERE Active
{
BinaryExpression exp = BinaryExpression.MakeBinary(ExpressionType.Equal, m, Expression.Constant(true));
return(this.VisitBinary(exp));
}
}
#if WinRT
if (m.Member.GetMemberType() == MemberTypes.Property)
#else
if (m.Member.MemberType == System.Reflection.MemberTypes.Property)
#endif
{
if (m.Member.Name == "OID")
{
currentWhere.AttributeName.Add("OID");
currentWhere.ParentType.Add(m.Member.DeclaringType);
}
else
{
if (m.Member.DeclaringType == typeof(string))
{
throw new Exceptions.LINQUnoptimizeException(string.Format("The member '{0}' is not supported", m.Member.Name));
}
System.Reflection.PropertyInfo pi = m.Member as System.Reflection.PropertyInfo;
#if SILVERLIGHT || CF || UNITY3D || WinRT || MONODROID
string fieldName = SilverlightPropertyResolver.GetPrivateFieldName(pi, pi.DeclaringType);
if (fieldName != null)
{
currentWhere.AttributeName.Add(fieldName);
currentWhere.ParentType.Add(m.Member.DeclaringType);
}
else
{
string fld = Sqo.Utilities.MetaHelper.GetBackingFieldByAttribute(m.Member);
if (fld != null)
{
currentWhere.AttributeName.Add(fld);
currentWhere.ParentType.Add(m.Member.DeclaringType);
}
else
{
throw new SiaqodbException("A Property must have UseVariable Attribute set( property:" + m.Member.Name + " of type:" + m.Member.DeclaringType.ToString() + ")");
}
}
#else
try
{
System.Reflection.FieldInfo fi = BackingFieldResolver.GetBackingField(pi);
if (fi != null)
{
currentWhere.AttributeName.Add(fi.Name);
currentWhere.ParentType.Add(m.Member.DeclaringType);
}
}
catch
{
string fld = Sqo.Utilities.MetaHelper.GetBackingFieldByAttribute(m.Member);
if (fld != null)
{
currentWhere.AttributeName.Add(fld);
currentWhere.ParentType.Add(m.Member.DeclaringType);
}
else
{
throw new SiaqodbException("A Property must have UseVariable Attribute set( property:" + m.Member.Name + " of type:" + m.Member.DeclaringType.ToString() + ")");
}
}
#endif
}
}
#if WinRT
else if (m.Member.GetMemberType() == MemberTypes.Field)
#else
else if (m.Member.MemberType == System.Reflection.MemberTypes.Field)
#endif
{
currentWhere.AttributeName.Add(m.Member.Name);
currentWhere.ParentType.Add(m.Member.DeclaringType);
}
else
{
throw new NotSupportedException("Unsupported Member Type!");
}
if (m.Expression.NodeType == ExpressionType.MemberAccess)
{
return(base.VisitMemberAccess(m));
}
else
{
return(m);
}
}
throw new Exceptions.LINQUnoptimizeException(string.Format("The member '{0}' is not supported", m.Member.Name));
}
private static System.Type GetType(SerializedProperty property)
{
System.Type parentType = property.serializedObject.targetObject.GetType();
System.Reflection.FieldInfo fi = NodeEditorWindow.GetFieldInfo(parentType, property.name);
return(fi.FieldType);
}
static SR.FieldInfo ResolveFieldDefinition(SR.FieldInfo field)
{
return(field.Module.ResolveField(field.MetadataToken));
}
public static void Register()
{
global::Orleans.Serialization.SerializationManager.Register(typeof(Example.CreateInventoryItem), DeepCopier, Serializer, Deserializer);
fieldInfo1 = typeof(Example.CreateInventoryItem).GetField("Name", (System.Reflection.BindingFlags.Instance
| (System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.NonPublic)));
}
public FieldReference Import(SR.FieldInfo field)
{
CheckField(field);
return(MetadataImporter.ImportField(field, null));
}
// parses the alternate names
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @SuppressWarnings("unchecked") private static <R extends Named> com.google.common.collect.ImmutableList<NamedLookup<R>> parseProviders(com.opengamma.strata.collect.io.IniFile config, Class<R> enumType)
private static ImmutableList <NamedLookup <R> > parseProviders <R>(IniFile config, Type <R> enumType) where R : Named
{
if (!config.contains(PROVIDERS_SECTION))
{
return(ImmutableList.of());
}
PropertySet section = config.section(PROVIDERS_SECTION);
ImmutableList.Builder <NamedLookup <R> > builder = ImmutableList.builder();
foreach (string key in section.keys())
{
Type cls;
try
{
cls = RenameHandler.INSTANCE.lookupType(key);
}
catch (Exception ex)
{
throw new System.ArgumentException("Unable to find enum provider class: " + key, ex);
}
string value = section.value(key);
if (value.Equals("constants"))
{
// extract public static final constants
builder.add(parseConstants(enumType, cls));
}
else if (value.Equals("lookup"))
{
// class is a named lookup
if (!cls.IsAssignableFrom(typeof(NamedLookup)))
{
//JAVA TO C# CONVERTER WARNING: The .NET Type.FullName property will not always yield results identical to the Java Class.getName method:
throw new System.ArgumentException("Enum provider class must implement NamedLookup " + cls.FullName);
}
try
{
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: Constructor<?> cons = cls.getDeclaredConstructor();
System.Reflection.ConstructorInfo <object> cons = cls.DeclaredConstructor;
if (!Modifier.isPublic(cls.Modifiers))
{
cons.Accessible = true;
}
builder.add((NamedLookup <R>)cons.newInstance());
}
catch (Exception ex)
{
//JAVA TO C# CONVERTER WARNING: The .NET Type.FullName property will not always yield results identical to the Java Class.getName method:
throw new System.ArgumentException("Invalid enum provider constructor: new " + cls.FullName + "()", ex);
}
}
else if (value.Equals("instance"))
{
// class has a named lookup INSTANCE static field
try
{
System.Reflection.FieldInfo field = cls.getDeclaredField("INSTANCE");
if (!Modifier.isStatic(field.Modifiers) || !field.Type.IsAssignableFrom(typeof(NamedLookup)))
{
//JAVA TO C# CONVERTER WARNING: The .NET Type.FullName property will not always yield results identical to the Java Class.getName method:
throw new System.ArgumentException("Invalid enum provider instance: " + cls.FullName + ".INSTANCE");
}
if (!Modifier.isPublic(cls.Modifiers) || !Modifier.isPublic(field.Modifiers))
{
field.Accessible = true;
}
builder.add((NamedLookup <R>)field.get(null));
}
catch (Exception ex)
{
//JAVA TO C# CONVERTER WARNING: The .NET Type.FullName property will not always yield results identical to the Java Class.getName method:
throw new System.ArgumentException("Invalid enum provider instance: " + cls.FullName + ".INSTANCE", ex);
}
}
else
{
throw new System.ArgumentException("Provider value must be either 'constants' or 'lookup'");
}
}
return(builder.build());
}
public FieldReference Import(SR.FieldInfo field, IGenericParameterProvider context)
{
return(ImportReference(field, context));
}
public FieldReference Import(SR.FieldInfo field, MethodReference context)
{
return(Import(field, (IGenericParameterProvider)context));
}
public FieldReference ImportReference(SR.FieldInfo field)
{
return(ImportReference(field, null));
}
private static object CopyOjbect(object obj)
{
if (obj == null)
{
return(null);
}
//拷贝目标
Object targetDeepCopyObj;
//元类型
Type targetType = obj.GetType();
//值类型
if (targetType.IsValueType == true)
{
targetDeepCopyObj = obj;
}
//引用类型
else
{
//创建引用对象
targetDeepCopyObj = System.Activator.CreateInstance(targetType);
//获取引用对象的所有公共成员
System.Reflection.MemberInfo[] memberCollection = obj.GetType().GetMembers();
foreach (System.Reflection.MemberInfo member in memberCollection)
{
//拷贝字段
if (member.MemberType == System.Reflection.MemberTypes.Field)
{
System.Reflection.FieldInfo field = (System.Reflection.FieldInfo)member;
Object fieldValue = field.GetValue(obj);
if (fieldValue is ICloneable)
{
field.SetValue(targetDeepCopyObj, (fieldValue as ICloneable).Clone());
}
else
{
field.SetValue(targetDeepCopyObj, CopyOjbect(fieldValue));
}
}//拷贝属性
else if (member.MemberType == System.Reflection.MemberTypes.Property)
{
System.Reflection.PropertyInfo myProperty = (System.Reflection.PropertyInfo)member;
MethodInfo info = myProperty.GetSetMethod(false);
if (info != null)
{
try
{
object propertyValue = myProperty.GetValue(obj, null);
if (propertyValue is ICloneable)
{
myProperty.SetValue(targetDeepCopyObj, (propertyValue as ICloneable).Clone(), null);
}
else
{
myProperty.SetValue(targetDeepCopyObj, CopyOjbect(propertyValue), null);
}
}
catch
{
//TODO
//输出你要处理的异常代码
}
}
}
}
}
return(targetDeepCopyObj);
}
private static CudafyModule DoCudafy(CudafyModule cm, params Type[] types)
{
MemoryStream output = new MemoryStream();
var outputSw = new StreamWriter(output);
MemoryStream structs = new MemoryStream();
var structsSw = new StreamWriter(structs);
var structsPto = new PlainTextOutput(structsSw);
MemoryStream declarations = new MemoryStream();
var declarationsSw = new StreamWriter(declarations);
var declarationsPto = new PlainTextOutput(declarationsSw);
MemoryStream code = new MemoryStream();
var codeSw = new StreamWriter(code);
var codePto = new PlainTextOutput(codeSw);
bool isDummy = false;
eCudafyDummyBehaviour behaviour = eCudafyDummyBehaviour.Default;
Dictionary <string, ModuleDefinition> modules = new Dictionary <string, ModuleDefinition>();
var compOpts = new DecompilationOptions {
FullDecompilation = true
};
CUDALanguage.Reset();
bool firstPass = true;
if (cm == null)
{
cm = new CudafyModule();// #######!!!
}
else
{
firstPass = false;
}
// Test structs
//foreach (var strct in types.Where(t => !t.IsClass))
// if (strct.GetCustomAttributes(typeof(CudafyAttribute), false).Length == 0)
// throw new CudafyLanguageException(CudafyLanguageException.csCUDAFY_ATTRIBUTE_IS_MISSING_ON_X, strct.Name);
IEnumerable <Type> typeList = GetWithNestedTypes(types);
foreach (var type in typeList)
{
if (!modules.ContainsKey(type.Assembly.Location))
{
modules.Add(type.Assembly.Location, ModuleDefinition.ReadModule(type.Assembly.Location));
}
}
// Additional loop to compile in order
foreach (var requestedType in typeList)
{
foreach (var kvp in modules)
{
foreach (var td in kvp.Value.Types)
{
List <TypeDefinition> tdList = new List <TypeDefinition>();
tdList.Add(td);
tdList.AddRange(td.NestedTypes);
Type type = null;
foreach (var t in tdList)
{
//type = typeList.Where(tt => tt.FullName.Replace("+", "") == t.FullName.Replace("/", "")).FirstOrDefault();
// Only select type if this matches the requested type (to ensure order is maintained).
type = requestedType.FullName.Replace("+", "") == t.FullName.Replace("/", "") ? requestedType : null;
if (type == null)
{
continue;
}
Debug.WriteLine(t.FullName);
// Types
var attr = t.GetCudafyType(out isDummy, out behaviour);
if (attr != null)
{
_cl.DecompileType(t, structsPto, compOpts);
if (firstPass)
{
cm.Types.Add(type.FullName.Replace("+", ""), new KernelTypeInfo(type, isDummy, behaviour));// #######!!!
}
}
else if (t.Name == td.Name)
{
// Fields
foreach (var fi in td.Fields)
{
attr = fi.GetCudafyType(out isDummy, out behaviour);
if (attr != null)
{
VerifyMemberName(fi.Name);
System.Reflection.FieldInfo fieldInfo = type.GetField(fi.Name, BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
if (fieldInfo == null)
{
throw new CudafyLanguageException(CudafyLanguageException.csX_ARE_NOT_SUPPORTED, "Non-static fields");
}
int[] dims = _cl.GetFieldInfoDimensions(fieldInfo);
_cl.DecompileCUDAConstantField(fi, dims, codePto, compOpts);
var kci = new KernelConstantInfo(fi.Name, fieldInfo, isDummy);
if (firstPass)
{
cm.Constants.Add(fi.Name, kci);// #######!!!
}
CUDALanguage.AddConstant(kci);
}
}
#warning TODO Only Global Methods can be called from host
#warning TODO For OpenCL may need to do Methods once all Constants have been handled
// Methods
foreach (var med in td.Methods)
{
attr = med.GetCudafyType(out isDummy, out behaviour);
if (attr != null)
{
if (!med.IsStatic)
{
throw new CudafyLanguageException(CudafyLanguageException.csX_ARE_NOT_SUPPORTED, "Non-static methods");
}
_cl.DecompileMethodDeclaration(med, declarationsPto, new DecompilationOptions {
FullDecompilation = false
});
_cl.DecompileMethod(med, codePto, compOpts);
MethodInfo mi = type.GetMethod(med.Name, BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
if (mi == null)
{
continue;
}
VerifyMemberName(med.Name);
eKernelMethodType kmt = eKernelMethodType.Device;
kmt = GetKernelMethodType(attr, mi);
if (firstPass)
{
cm.Functions.Add(med.Name, new KernelMethodInfo(type, mi, kmt, isDummy, behaviour, cm));// #######!!!
}
}
}
}
}
}
}
}
codeSw.Flush();
if (CudafyTranslator.Language == eLanguage.OpenCL)
{
outputSw.WriteLine("#if defined(cl_khr_fp64)");
outputSw.WriteLine("#pragma OPENCL EXTENSION cl_khr_fp64: enable");
outputSw.WriteLine("#elif defined(cl_amd_fp64)");
outputSw.WriteLine("#pragma OPENCL EXTENSION cl_amd_fp64: enable");
outputSw.WriteLine("#endif");
}
foreach (var oh in CUDALanguage.OptionalHeaders)
{
if (oh.Used && !oh.AsResource)
{
outputSw.WriteLine(oh.IncludeLine);
}
else if (oh.Used)
{
outputSw.WriteLine(GetResourceString(oh.IncludeLine));
}
}
foreach (var oh in CUDALanguage.OptionalFunctions)
{
if (oh.Used)
{
outputSw.WriteLine(oh.Code);
}
}
declarationsSw.WriteLine();
declarationsSw.Flush();
structsSw.WriteLine();
structsSw.Flush();
foreach (var def in cm.GetDummyDefines())
{
outputSw.WriteLine(def);
}
foreach (var inc in cm.GetDummyStructIncludes())
{
outputSw.WriteLine(inc);
}
foreach (var inc in cm.GetDummyIncludes())
{
outputSw.WriteLine(inc);
}
outputSw.Flush();
output.Write(structs.GetBuffer(), 0, (int)structs.Length);
output.Write(declarations.GetBuffer(), 0, (int)declarations.Length);
output.Write(code.GetBuffer(), 0, (int)code.Length);
outputSw.Flush();
#if DEBUG
using (FileStream fs = new FileStream("output.cu", FileMode.Create))
{
fs.Write(output.GetBuffer(), 0, (int)output.Length);
}
#endif
String s = Encoding.UTF8.GetString(output.GetBuffer(), 0, (int)output.Length);
//cm.SourceCode = s;// #######!!!
var scf = new SourceCodeFile(s, Language, _architecture);
cm.AddSourceCodeFile(scf);
return(cm);
}
private void DrawNormalValue(System.Reflection.FieldInfo filed, Rect rect, object o)
{
switch (filed.FieldType.ToString())
{
case "UnityEngine.Vector3":
filed.SetValue(o, EditorGUI.Vector3Field(rect, "", (Vector3)filed.GetValue(o)));
rect = GetGUILeftScrollAreaRect(60, rect.width, rect.height, true);
Transform t = null;
t = EditorGUI.ObjectField(rect, t, typeof(Transform), true) as Transform;
if (t)
{
filed.SetValue(o, t.position);
}
break;
case "UnityEngine.Vector2":
filed.SetValue(o, EditorGUI.Vector2Field(rect, "", (Vector2)filed.GetValue(o)));
break;
case "System.Single":
filed.SetValue(o, EditorGUI.FloatField(rect, (float)filed.GetValue(o)));
break;
case "System.Int32":
filed.SetValue(o, EditorGUI.IntField(rect, (int)filed.GetValue(o)));
break;
case "System.String":
filed.SetValue(o, EditorGUI.TextField(rect, (string)filed.GetValue(o)));
break;
case "System.Boolean":
filed.SetValue(o, EditorGUI.Toggle(rect, (bool)filed.GetValue(o)));
break;
case "System.String[]":
//高级编辑功能
rect = GetGUILeftScrollAreaRect(80, 90, 20, false);
if (GUI.Button(rect, "<color=#00FF00>Advance Edit</color>", ResourcesManager.GetInstance.skin.button))
{
AdvanceStringArrayEditor.Open(o, filed);
}
//通常编辑功能
string[] array = filed.GetValue(o) as string[];
rect = GetGUILeftScrollAreaRect(175, 20, 18);
LeftHeightSpace(6);
if (GUI.Button(rect, "+", ResourcesManager.GetInstance.skin.button))
{
Array.Resize <string>(ref array, array.Length + 1);
}
if (array == null)
{
array = new string[] { }
}
;
for (int j = 0; j < array.Length; j++)
{
rect = GetGUILeftScrollAreaRect(10, 160, 18, false);
array[j] = EditorGUI.TextField(rect, (string)array[j]);
rect = GetGUILeftScrollAreaRect(175, 20, 18);
if (GUI.Button(rect, "-", ResourcesManager.GetInstance.skin.button))
{
for (int n = j; n < array.Length - 1; n++)
{
array[j] = array[j + 1];
}
Array.Resize <string>(ref array, array.Length - 1);
break;
}
LeftHeightSpace(2);
}
filed.SetValue(o, array);
break;
default:
if (filed.FieldType.BaseType.ToString() == "System.Enum")
{
//System.Enum.Parse(filed.FieldType.DeclaringType, (string)filed.GetValue(_currentNode));
filed.SetValue(o, EditorGUI.EnumPopup(rect, (System.Enum)filed.GetValue(o)));
}
else
{
EditorGUI.LabelField(rect, "Not Deal Object.");
}
break;
}
}
public static FieldReference ImportEx(this ModuleDefinition module, System.Reflection.FieldInfo field, IGenericParameterProvider context)
{
throw new NotImplementedException();
}
private Type GenerateOneToOneColumn(IndentingTextWriter writer, string className, Type columnType,
System.Reflection.FieldInfo fieldInfo, ArgumentAttribute inputAttr, Type type, bool isArray)
{
var fieldName = CSharpGeneratorUtils.Capitalize(inputAttr.Name ?? fieldInfo.Name);
var generatedType = _generatedClasses.GetApiName(type, "");
writer.WriteLine($"public {className}()");
writer.WriteLine("{");
writer.WriteLine("}");
writer.WriteLine("");
writer.WriteLine($"public {className}(params string[] input{fieldName}s)");
writer.WriteLine("{");
writer.Indent();
writer.WriteLine($"if (input{fieldName}s != null)");
writer.WriteLine("{");
writer.Indent();
writer.WriteLine($"foreach (string input in input{fieldName}s)");
writer.WriteLine("{");
writer.Indent();
writer.WriteLine($"Add{fieldName}(input);");
writer.Outdent();
writer.WriteLine("}");
writer.Outdent();
writer.WriteLine("}");
writer.Outdent();
writer.WriteLine("}");
writer.WriteLine("");
writer.WriteLine($"public {className}(params (string inputColumn, string outputColumn)[] inputOutput{fieldName}s)");
writer.WriteLine("{");
writer.Indent();
writer.WriteLine($"if (inputOutput{fieldName}s != null)");
writer.WriteLine("{");
writer.Indent();
writer.WriteLine($"foreach (var inputOutput in inputOutput{fieldName}s)");
writer.WriteLine("{");
writer.Indent();
writer.WriteLine($"Add{fieldName}(inputOutput.outputColumn, inputOutput.inputColumn);");
writer.Outdent();
writer.WriteLine("}");
writer.Outdent();
writer.WriteLine("}");
writer.Outdent();
writer.WriteLine("}");
writer.WriteLine("");
writer.WriteLine($"public void Add{fieldName}(string inputColumn)");
writer.WriteLine("{");
writer.Indent();
if (isArray)
{
writer.WriteLine($"var list = {fieldName} == null ? new List<{generatedType}>() : new List<{generatedType}>({fieldName});");
writer.WriteLine($"list.Add(OneToOneColumn<{generatedType}>.Create(inputColumn));");
writer.WriteLine($"{fieldName} = list.ToArray();");
}
else
{
writer.WriteLine($"{fieldName} = OneToOneColumn<{generatedType}>.Create(inputColumn);");
}
writer.Outdent();
writer.WriteLine("}");
writer.WriteLine();
writer.WriteLine($"public void Add{fieldName}(string outputColumn, string inputColumn)");
writer.WriteLine("{");
writer.Indent();
if (isArray)
{
writer.WriteLine($"var list = {fieldName} == null ? new List<{generatedType}>() : new List<{generatedType}>({fieldName});");
writer.WriteLine($"list.Add(OneToOneColumn<{generatedType}>.Create(outputColumn, inputColumn));");
writer.WriteLine($"{fieldName} = list.ToArray();");
}
else
{
writer.WriteLine($"{fieldName} = OneToOneColumn<{generatedType}>.Create(outputColumn, inputColumn);");
}
writer.Outdent();
writer.WriteLine("}");
writer.WriteLine();
Contracts.Assert(columnType == null);
columnType = type;
return(columnType);
}
public FieldReference ImportField(SR.FieldInfo field)
{
return(ImportField(field, default(ImportGenericContext)));
}
internal PropInfo(object obj, System.Reflection.FieldInfo field)
{
this.obj = obj;
this.field = field;
}
public override void Execute(MethodInfo aMethod, ILOpCode aOpCode)
{
var xType = aMethod.MethodBase.DeclaringType;
var xOpCode = (ILOpCodes.OpField)aOpCode;
SysReflection.FieldInfo xField = xOpCode.Value;
// call cctor:
var xCctor = (xField.DeclaringType.GetConstructors(BindingFlags.Static | BindingFlags.NonPublic) ?? new ConstructorInfo[0]).SingleOrDefault();
if (xCctor != null && xCctor.DeclaringType != aMethod.MethodBase.DeclaringType)
{
new CPUx86.Call {
DestinationLabel = LabelName.Get(xCctor)
};
ILOp.EmitExceptionLogic(Assembler, aMethod, aOpCode, true, null, ".AfterCCTorExceptionCheck");
new Label(".AfterCCTorExceptionCheck");
}
//int aExtraOffset;// = 0;
//bool xNeedsGC = xField.FieldType.IsClass && !xField.FieldType.IsValueType;
uint xSize = SizeOfType(xField.FieldType);
//if( xNeedsGC )
//{
// aExtraOffset = 12;
//}
new Comment(Assembler, "Type = '" + xField.FieldType.FullName /*+ "', NeedsGC = " + xNeedsGC*/);
uint xOffset = 0;
var xFields = xField.DeclaringType.GetFields();
foreach (SysReflection.FieldInfo xInfo in xFields)
{
if (xInfo == xField)
{
break;
}
xOffset += SizeOfType(xInfo.FieldType);
}
string xDataName = DataMember.GetStaticFieldName(xField);
for (int i = 0; i < (xSize / 4); i++)
{
new CPUx86.Pop {
DestinationReg = CPUx86.Registers.EAX
};
new CPUx86.Mov {
DestinationRef = Cosmos.Assembler.ElementReference.New(xDataName, i * 4), DestinationIsIndirect = true, SourceReg = CPUx86.Registers.EAX
};
}
switch (xSize % 4)
{
case 1:
{
new CPUx86.Pop {
DestinationReg = CPUx86.Registers.EAX
};
new CPUx86.Mov {
DestinationRef = Cosmos.Assembler.ElementReference.New(xDataName, ( int )((xSize / 4) * 4)), DestinationIsIndirect = true, SourceReg = CPUx86.Registers.AL
};
break;
}
case 2:
{
new CPUx86.Pop {
DestinationReg = CPUx86.Registers.EAX
};
new CPUx86.Mov {
DestinationRef = Cosmos.Assembler.ElementReference.New(xDataName, ( int )((xSize / 4) * 4)), DestinationIsIndirect = true, SourceReg = CPUx86.Registers.AX
};
break;
}
case 0:
{
break;
}
default:
//EmitNotImplementedException(Assembler, GetServiceProvider(), "Ldsfld: Remainder size " + (xSize % 4) + " not supported!", mCurLabel, mMethodInformation, mCurOffset, mNextLabel);
throw new NotImplementedException();
//break;
}
}
/// <summary>
/// Set the value of one property of this object.
/// </summary>
/// <param name="name">Name of the field to be set.</param>
/// <param name="value">String representation of the value of the field.</param>
/// <returns>True of the field could be set with the given value. False if there is no field with the given name.</returns>
public bool setSetting(string name, string value)
{
// Replace '-' in ml settings name with underscore since '-' isnt a valid symbol for names.
// Now both underscore and '-' are supported for uniform naming.
if (name.Contains("-"))
{
name = name.Replace("-", "_");
}
System.Reflection.FieldInfo fi = this.GetType().GetField(name);
if (fi == null)
{
return(false);
}
string asa = fi.FieldType.FullName;
// The processing of the blacklist
if (name.ToLower().Equals("blacklisted"))
{
String[] optionsToBlacklist = value.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
foreach (String option in optionsToBlacklist)
{
this.blacklisted.Add(option.ToLower());
}
this.blacklisted = this.blacklisted.Distinct().ToList();
return(true);
}
if (fi.FieldType.FullName.Equals("System.Boolean"))
{
if (value.ToLowerInvariant() == "true" || value.ToLowerInvariant() == "false")
{
fi.SetValue(this, Convert.ToBoolean(value));
return(true);
}
else
{
return(false);
}
}
if (fi.FieldType.FullName.Equals("System.Int32"))
{
int n;
bool isNumeric = int.TryParse(value, out n);
if (isNumeric)
{
fi.SetValue(this, n);
return(true);
}
else
{
return(false);
}
}
if (fi.FieldType.FullName.Equals("System.Int64"))
{
int n;
bool isNumeric = int.TryParse(value, out n);
if (isNumeric)
{
fi.SetValue(this, n);
return(true);
}
else
{
return(false);
}
}
if (fi.FieldType.FullName.Equals("MachineLearning.Learning.ML_Settings+LossFunction"))
{
if (value.Equals("RELATIVE"))
{
fi.SetValue(this, LossFunction.RELATIVE);
return(true);
}
if (value.Equals("LEASTSQUARES"))
{
fi.SetValue(this, LossFunction.LEASTSQUARES);
return(true);
}
if (value.Equals("ABSOLUTE"))
{
fi.SetValue(this, LossFunction.ABSOLUTE);
return(true);
}
}
if (fi.FieldType.FullName.Equals("System.Double"))
{
double n;
bool isNumeric = double.TryParse(value, out n);
if (isNumeric)
{
fi.SetValue(this, n);
return(true);
}
else
{
return(false);
}
}
if (fi.FieldType.FullName.Equals("System.TimeSpan"))
{
TimeSpan n;
bool isValid = TimeSpan.TryParse(value, out n);
if (isValid)
{
fi.SetValue(this, n);
return(true);
}
else
{
return(false);
}
}
if (fi.FieldType.FullName.Equals("MachineLearning.Learning.ML_Settings+ScoreMeasure"))
{
ScoreMeasure parsedValue;
try
{
parsedValue = (ScoreMeasure)Enum.Parse(typeof(ScoreMeasure), value.ToUpperInvariant());
}
catch (ArgumentException)
{
return(false);
}
fi.SetValue(this, parsedValue);
return(true);
}
return(false);
}
public virtual FieldReference ImportReference(SR.FieldInfo field, IGenericParameterProvider context)
{
Mixin.CheckField(field);
return(ImportField(field, ImportGenericContext.For(context)));
}
/// <summary>
/// 处理一张表 Handle A table.
/// </summary>
/// <param name="result">Result.</param>
public static bool HandleATable(DataTable result)
{
Debug.Log(result.TableName);
//创建这个类
Type t = Type.GetType(GetClassNameByName(result.TableName));
if (t == null)
{
Debug.Log("the type is null : " + result.TableName);
return(false);
}
int columns = result.Columns.Count;
int rows = result.Rows.Count;
//行数从0开始 第0行为注释
int fieldsRow = 1; //字段名所在行数
int contentStarRow = 2; //内容起始行数
//获取所有字段
string[] tableFields = new string[columns];
for (int j = 0; j < columns; j++)
{
tableFields[j] = result.Rows[fieldsRow][j].ToString();
//Debuger.Log(tableFields[j]);
}
//存储表内容的字典
List <ConfigClass> datalist = new List <ConfigClass>();
//遍历所有内容
for (int i = contentStarRow; i < rows; i++)
{
ConfigClass o = Activator.CreateInstance(t) as ConfigClass;
for (int j = 0; j < columns; j++)
{
System.Reflection.FieldInfo info = o.GetType().GetField(tableFields[j]);
if (info == null)
{
continue;
}
string val = result.Rows[i][j].ToString();
if (info.FieldType == typeof(int))
{
info.SetValue(o, int.Parse(val));
}
else if (info.FieldType == typeof(float))
{
info.SetValue(o, float.Parse(val));
}
else
{
info.SetValue(o, val);
}
//Debuger.Log(val);
}
datalist.Add(o);
}
SaveTableData(datalist, result.TableName + ".msconfig");
return(true);
}
public void OnValueChanged(System.Reflection.FieldInfo field, object oldValue, object newValue)
{
}