static void Main(string[] args)
{
GenericType<int>.GenericMethod();
//GenericType<int>.GenericMethod<string>();
GenericType<int> a = new GenericType<int>();
a.GenericMethod<string>();
}
public TokenRequirements(Generic generic)
{
requirementsFor = generic.type;
genericTypesNeeded = generic.typesNeeded;
allowSymbols = generic.allowSymbols;
allNum = generic.allDigits;
allAlpha = generic.allAlpha;
sizeMatters = generic.size != -1;
requiresClosure = generic.requiresClosure;
size = generic.size;
genType = generic.genericType;
}
public static int Create(GenericType Rate)
{
SqlCommand SQLCmd = new SqlCommand();
SQLCmd.CommandType = CommandType.StoredProcedure;
SQLCmd.CommandText = "CreateSalaryRate";
SQLCmd.Parameters.Add("Name", SqlDbType.NVarChar, 100).Value = Rate.Name;
SQLCmd.Parameters.Add("Id", SqlDbType.Int).Direction = ParameterDirection.Output;
BaseDataAccess.OpenConnection(SQLCmd);
BaseDataAccess.ExecuteNonSelect(SQLCmd);
BaseDataAccess.CloseConnection();
return Convert.ToInt32(SQLCmd.Parameters["Id"].Value);
}
public IConfiguration DriverConfigurations <T>(GenericType <T> activeContextHandlerType) where T : IObserver <IActiveContext>
{
return(TangFactory.GetTang().NewConfigurationBuilder(
DriverConfiguration.ConfigurationModule
.Set(DriverConfiguration.OnDriverStarted, GenericType <ContextStackHandlers> .Class)
.Set(DriverConfiguration.OnEvaluatorAllocated, GenericType <ContextStackHandlers> .Class)
.Set(DriverConfiguration.OnContextActive, activeContextHandlerType)
.Set(DriverConfiguration.OnTaskMessage, GenericType <HelloTaskMessageHandler> .Class)
.Set(DriverConfiguration.OnTaskCompleted, GenericType <ContextStackHandlers> .Class)
.Set(DriverConfiguration.OnContextClosed, GenericType <ContextStackHandlers> .Class)
.Build())
.Build());
}
private static void TransformGeneric(GenericType type, Func <string, string> typeNameTransformer)
{
if (type == null)
{
return;
}
type.GenericTypeName = typeNameTransformer(type.GenericTypeName);
foreach (var typeArg in type.Arguments)
{
TransformGeneric(typeArg, typeNameTransformer);
}
}
private static void TransformGeneric(GenericType type, Func<string, string> typeNameTransformer)
{
if (type == null)
{
return;
}
type.GenericTypeName = typeNameTransformer(type.GenericTypeName);
foreach (var typeArg in type.Arguments)
{
TransformGeneric(typeArg, typeNameTransformer);
}
}
internal static XMLSerializableType GetRandom()
{
XMLSerializableType result = new()
{
Cyle = CycleA.GetRandom(),
SimpleDataStructure1 = SimpleDataStructure1.GetRandom(),
GenericInt = new GenericType <int>()
{
TList = new List <int>()
{
21, 22
},
TSet = new HashSet <int>()
{
23, 24
},
TObject = 42,
Enumerable = new ArrayList()
{
25, 26
},
TDictionary1 = new Dictionary <string, int>()
{
{ "key1", 27 }, { "key2", 28 }
},
TDictionary2 = new Dictionary <int, int>()
{
{ 29, 30 }, { 31, 32 }
},
TEnumerable = new List <int>()
{
27, 28
},
},
GenericSimpleDataStructure1 = new GenericType <SimpleDataStructure1>()
{
TList = new List <SimpleDataStructure1>()
{
SimpleDataStructure1.GetRandom(), SimpleDataStructure1.GetRandom()
},
TSet = new HashSet <SimpleDataStructure1>()
{
SimpleDataStructure1.GetRandom(), SimpleDataStructure1.GetRandom()
},
TDictionary1 = new Dictionary <string, SimpleDataStructure1>()
{
{ "key", null }
},
TDictionary2 = new Dictionary <int, SimpleDataStructure1>()
{
{ 5, SimpleDataStructure1.GetRandom() }, { default, SimpleDataStructure1.GetRandom() }
/// <summary>
/// 获取成员转换函数信息
/// </summary>
/// <param name="type">成员类型</param>
/// <param name="isCustom"></param>
/// <returns>成员转换函数信息</returns>
internal static MethodInfo GetMemberMethodInfo(Type type, ref bool isCustom)
{
MethodInfo methodInfo = JsonDeSerializer.GetDeSerializeMethod(type);
if (methodInfo != null)
{
return(methodInfo);
}
if (type.IsArray)
{
return(GenericType.Get(type.GetElementType()).JsonDeSerializeArrayMethod.Method);
}
if (type.IsEnum)
{
if (type.IsDefined(typeof(FlagsAttribute), false))
{
return((EnumGenericType.Get(type).JsonDeSerializeEnumFlagsDelegate).Method);
}
return((EnumGenericType.Get(type).JsonDeSerializeEnumDelegate).Method);
}
if (type.IsGenericType)
{
Type genericType = type.GetGenericTypeDefinition();
if (genericType == typeof(Dictionary <,>))
{
return(GenericType2.Get(type.GetGenericArguments()).JsonDeSerializeDictionaryMethod.Method);
}
if (genericType == typeof(Nullable <>))
{
return(GetNullable(type).Method);
}
if (genericType == typeof(KeyValuePair <,>))
{
return(GenericType2.Get(type.GetGenericArguments()).JsonDeSerializeKeyValuePairMethod.Method);
}
}
if ((methodInfo = GetCustom(type)) != null)
{
isCustom = type.IsValueType;
return(methodInfo);
}
if ((methodInfo = GetIEnumerableConstructor(type)) != null)
{
return(methodInfo);
}
if (type.IsValueType)
{
return(StructGenericType.Get(type).JsonDeSerializeStructMethod);
}
return(GenericType.Get(type).JsonDeSerializeTypeMethod);
}
/// <summary>
/// Type reference entry.
///
/// (namespace_reference '::')? type_name generic_types?
/// </summary>
/// <param name="context"></param>
public override void EnterType_reference(KryptonParser.Type_referenceContext context)
{
// pass if we are a generic attribute reference.
var attribute = context.generic_attribute_reference();
if (attribute != null)
{
return;
}
var parent = _typeReferenceContainers.Peek();
var name = context.type_name().GetText();
var ns = context.namespace_reference()?.GetText() ?? "";
// if "this" is the namespace we are referencing the local context
// setting the namespace to nothing will make us look through the active context first
if (ns == LocalNamespaceToken)
{
ns = "";
}
var path = ns.Split(new[] { NamespaceDelimiterToken }, StringSplitOptions.RemoveEmptyEntries);
var activeContext = _contextStack.Peek();
// Resolve the member reference
if (!TryResolveMember(path, name, activeContext, out var member))
{
throw new KryptonParserException($"Unable to resolve type {ns} {name}");
}
IType type;
// If we are a generic type...
var generic = context.generic_types() != null;
if (generic)
{
type = new GenericType(name);
_typeReferenceContainers.Push((ITypeReferenceContainer)type);
}
else
{
type = new ConcreteType(name);
}
// Create a type reference and add it to our parent.
var reference = new FormalTypeReference(type, member.Parent);
parent.AddTypeReference(reference);
}
public static TypeBase MakeGenericInstance(this GenericType genericType, TypeBase genericTemplateType)
{
// TODO cache generic instance that are using predefined hlsl types
var newType = genericTemplateType.DeepClone();
var genericParameters = ((IGenerics)genericTemplateType).GenericParameters;
var genericArguments = ((IGenerics)newType).GenericArguments;
var genericInstanceParameters = genericType.Parameters;
var genericParameterTypes = new TypeBase[genericParameters.Count];
var genericBaseParameterTypes = new TypeBase[genericParameters.Count];
// Look for parameter instance types
for (int i = 0; i < genericInstanceParameters.Count; i++)
{
var genericInstanceParameter = genericInstanceParameters[i];
if (genericInstanceParameter is TypeBase)
{
var genericInstanceParameterType = (TypeBase)genericInstanceParameter;
genericParameterTypes[i] = genericInstanceParameterType;
genericBaseParameterTypes[i] = TypeBase.GetBaseType(genericInstanceParameterType);
genericParameters[i] = genericParameterTypes[i];
genericArguments.Add(genericInstanceParameterType);
}
}
// Replace all references to template arguments to their respective generic instance types
SearchVisitor.Run(
newType,
node =>
{
var typeInferencer = node as ITypeInferencer;
if (typeInferencer != null && typeInferencer.TypeInference.Declaration is GenericDeclaration)
{
var genericDeclaration = (GenericDeclaration)typeInferencer.TypeInference.Declaration;
var i = genericDeclaration.Index;
var targeType = genericDeclaration.IsUsingBase ? genericBaseParameterTypes[i] : genericParameterTypes[i];
if (node is TypeBase)
{
return(targeType.ResolveType());
}
}
return(node);
});
return(newType);
}
GenericType[] SetTokens(string[] tokenIds)
{
var types = new GenericType[tokenIds.Length];
for (int i = 0; i < tokenIds.Length; i++)
{
var id = int.Parse(tokenIds[i]);
if (id != -1)
types[i] = (GenericType)id;
else
types = null;
}
return types;
}
public void Generic()
{
var expected = new TypeParts("GenericType", "ns123", new[]
{
new TypeParts("string", "sys"),
new TypeParts("int"),
new TypeParts("SomeOtherType", "ns4")
}.ToImmutableArray);
var actual = TypePartsParser.Default.Get(GenericType);
Assert.Equal(expected, actual, TypePartsEqualityComparer.Default);
Assert.Equal(GenericType.Replace(" ", ""), TypePartsFormatter.Default.Get(actual));
}
public virtual MemberSymbol GetMember(string name)
{
if (memberTable.ContainsKey(name))
{
return(memberTable[name]);
}
if (GenericType?.GetMember(name) is MemberSymbol member)
{
return(member);
}
return(null);
}
///// <summary>
///// 引用类型解析调用函数信息集合
///// </summary>
//private static readonly AutoCSer.Threading.LockDictionary<Type, MethodInfo> typeMethods = new AutoCSer.Threading.LockDictionary<Type, MethodInfo>();
///// <summary>
///// 引用类型对象解析函数信息
///// </summary>
//private static readonly MethodInfo typeParseMethod = typeof(Parser).GetMethod("typeParse", BindingFlags.Instance | BindingFlags.NonPublic);
///// <summary>
///// 获取引用类型解析调用函数信息
///// </summary>
///// <param name="type">数据类型</param>
///// <returns>引用类型解析调用函数信息</returns>
//public static MethodInfo GetType(Type type)
//{
// MethodInfo method;
// if (typeMethods.TryGetValue(type, out method)) return method;
// //if (type.GetConstructor(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance, null, nullValue<Type>.Array, null) == null) method = noConstructorMethod.MakeGenericMethod(type);
// //else
// method = typeParseMethod.MakeGenericMethod(type);
// typeMethods.Set(type, method);
// return method;
//}
/// <summary>
/// 获取成员转换函数信息
/// </summary>
/// <param name="type">成员类型</param>
/// <param name="isCustom"></param>
/// <returns>成员转换函数信息</returns>
internal static MethodInfo GetMemberMethodInfo(Type type, ref bool isCustom)
{
MethodInfo methodInfo = Parser.GetParseMethod(type);
if (methodInfo != null)
{
return(methodInfo);
}
//if (type.IsArray) return GetArray(type.GetElementType());
if (type.IsArray)
{
return(GenericType.Get(type.GetElementType()).XmlParseArrayMethod);
}
if (type.IsEnum)
{
return(GetEnum(type));
}
if (type.IsGenericType)
{
Type genericType = type.GetGenericTypeDefinition();
if (genericType == typeof(Nullable <>))
{
Type[] parameterTypes = type.GetGenericArguments();
//return parameterTypes[0].IsEnum ? GetNullableEnumParse(type, parameterTypes) : GetNullableParse(type, parameterTypes);
return(parameterTypes[0].IsEnum ? StructGenericType.Get(parameterTypes[0]).XmlParseNullableEnumMethod : StructGenericType.Get(parameterTypes[0]).XmlParseNullableMethod);
}
//if (genericType == typeof(KeyValuePair<,>)) return GetKeyValuePair(type);
if (genericType == typeof(KeyValuePair <,>))
{
return(GenericType2.Get(type.GetGenericArguments()).XmlParseKeyValuePairMethod);
}
}
if ((methodInfo = GetCustom(type)) != null)
{
isCustom = type.IsValueType;
return(methodInfo);
}
//if (type.IsAbstract || type.IsInterface) return typeParser.GetNoConstructorParser(type);
if ((methodInfo = GetIEnumerableConstructor(type)) != null)
{
return(methodInfo);
}
if (type.IsValueType)
{
return(GetValueType(type));
}
//return GetType(type);
return(GenericType.Get(type).XmlParseTypeMethod);
}
public void TestGenerics()
{
// Create the open class<T> which contains a List<T>
GenericType genericClassArg = new GenericType("T");
Class openClass = new Class();
openClass.Name = "OpenClass";
openClass.Namespace = "Namespace";
openClass.DeclaredGenericArguments.Add(genericClassArg);
TypeSpecifier listType = typeof(List <>);
Assert.AreEqual(listType.GenericArguments.Count, 1);
listType.GenericArguments[0] = genericClassArg;
Method openMethod = new Method("OpenMethod");
openMethod.ArgumentTypes.Add(listType);
GraphUtil.ConnectExecPins(openMethod.EntryNode.InitialExecutionPin, openMethod.ReturnNode.ReturnPin);
openClass.Methods.Add(openMethod);
// Create the closed class which contains a List<string>
Class closedClass = new Class();
closedClass.Name = "ClosedClass";
closedClass.Namespace = "Namespace";
TypeSpecifier closedListType = typeof(List <string>);
Method closedMethod = new Method("ClosedMethod");
closedMethod.ArgumentTypes.Add(closedListType);
GraphUtil.ConnectExecPins(closedMethod.EntryNode.InitialExecutionPin, closedMethod.ReturnNode.ReturnPin);
closedClass.Methods.Add(closedMethod);
// Translate the classes
ClassTranslator translator = new ClassTranslator();
string openClassTranslated = translator.TranslateClass(openClass);
string closedClassTranslated = translator.TranslateClass(closedClass);
}
public void SetGenTypes(string genTyps)
{
var typeList = new List<GenericType[]>();
var split = genTyps.Split(',');
if (split.Length > 0)
{
GenericType[] types;
foreach (var str in split)
{
var eachType = str.Split('/');
types = new GenericType[eachType.Length];
if (eachType.Length > 0)
{
for (int i = 0; i < eachType.Length; i++)
{
var parse = int.Parse(eachType[i]);
types[i] = (GenericType)parse;
}
}
else
{
types = new GenericType[1];
types[0] = (GenericType)int.Parse(str);
}
typeList.Add(types);
}
}
else
{
var anotherSplit = genTyps.Split('/');
if (anotherSplit.Length > 0)
{
GenericType[] gTypes = new GenericType[anotherSplit.Length];
for (int i = 0; i < anotherSplit.Length; i++)
{
var gType = (GenericType)int.Parse(anotherSplit[i]);
gTypes[i] = gType;
}
typeList.Add(gTypes);
}
else
{
var lonelyType = new GenericType[1];
lonelyType[0] = (GenericType)int.Parse(genTyps);
}
typesNeeded = typeList.ToArray();
}
}
static ITypeContainer CreateABinaryContainerGeneric(
Type SourceObjectType, byte[] SerializedObject)
{
Type g;
if (!GenericContainersTypeCache.TryGetValue(SourceObjectType, out g))
{
Type[] typeArgs = { SourceObjectType };
g = GenericType.MakeGenericType(typeArgs);
GenericContainersTypeCache.Add(SourceObjectType, g);
}
object o = Activator.CreateInstance(g, SerializedObject);
return(o as ITypeContainer);
}
public void GenericTypeTest()
{
var input = new GenericType <GenericType <int, int>, int>();
input.FieldOne = new GenericType <int, int>();
input.FieldOne.FieldOne = 500;
input.FieldOne.FieldTwo = 300;
input.FieldTwo = 200;
var output = SerializeDeserialize(input);
Assert.AreEqual(input.FieldOne.FieldOne, output.FieldOne.FieldOne);
Assert.AreEqual(input.FieldOne.FieldTwo, output.FieldOne.FieldTwo);
Assert.AreEqual(input.FieldTwo, output.FieldTwo);
}
private void BuildConstructor(GenericTemplate classType, System.Reflection.ConstructorInfo constructorInfo)
{
var args = constructorInfo.GetParameters().Select(
x => new VarInfo(
x.Name,
x.ParameterType.FullName == null?
GenericType.Get(x.ParameterType.GenericParameterPosition):
storage.GetType(ConvertMSILNames(x.ParameterType))
)).ToList();
if (args.All(x => x.Type != null))
{
classType.AddConstructor(args);
}
}
public ConfigurationModuleBuilder BindSetEntry <U, T>(GenericType <U> iface, IParam <T> opt)
where U : Name <ISet <T> >
{
ConfigurationModuleBuilder c = DeepCopy();
Type ifaceType = typeof(U);
c.ProcessUse(opt);
c.FreeParams.Add(ifaceType, opt);
if (!SetOpts.Contains(opt))
{
c.SetOpts.Add(opt);
}
return(c);
}
static ITypeContainer CreateATypeContainerGeneric(
Type SourceObjectType)
{
Type g;
if (!GenericContainersTypeCache.TryGetValue(SourceObjectType, out g))
{
Type[] typeArgs = { SourceObjectType };
g = GenericType.MakeGenericType(typeArgs);
GenericContainersTypeCache.Add(SourceObjectType, g);
}
object o = Activator.CreateInstance(g, SourceObjectType.AssemblyQualifiedName);
return(o as ITypeContainer);
}
protected override void Validate()
{
if (!BaseType.IsInterface)
{
throw new InvalidBindingException($"Factory type {BaseType.Name} is not an interface.");
}
else if (!GenericType.IsAssignableFrom(ImplementationType))
{
throw new InvalidBindingException($"{ImplementationType.Name} is not a subclass of the base type {GenericType.Name}.");
}
else if (ImplementationType.IsInterface || ImplementationType.IsAbstract)
{
throw new InvalidBindingException($"{ImplementationType.Name} cannot be instantiated, it is either an interface or abstract class.");
}
}
/// <summary>
/// 获取成员转换函数信息
/// </summary>
/// <param name="type">成员类型</param>
/// <param name="isCustom">成员类型</param>
/// <returns>成员转换函数信息</returns>
internal static MethodInfo GetMemberMethodInfo(Type type, ref bool isCustom)
{
MethodInfo methodInfo = Serializer.GetSerializeMethod(type);
if (methodInfo != null)
{
return(methodInfo);
}
//if (type.IsArray) return GetArray(type.GetElementType());
if (type.IsArray)
{
Type elementType = type.GetElementType();
if (elementType.IsValueType && (!elementType.IsGenericType || elementType.GetGenericTypeDefinition() != typeof(Nullable <>)))
{
return(StructGenericType.Get(elementType).JsonSerializeStructArrayMethod);
}
return(GenericType.Get(elementType).JsonSerializeArrayMethod);
}
//if (type.IsEnum) return GetEnum(type);
if (type.IsEnum)
{
return(GenericType.Get(type).JsonSerializeEnumToStringMethod);
}
if (type.IsGenericType)
{
Type genericType = type.GetGenericTypeDefinition();
if (genericType == typeof(Dictionary <,>))
{
return(GetDictionary(type));
}
//if (genericType == typeof(Nullable<>)) return GetNullable(type);
if (genericType == typeof(Nullable <>))
{
return(StructGenericType.Get(type.GetGenericArguments()[0]).JsonSerializeNullableMethod);
}
//if (genericType == typeof(KeyValuePair<,>)) return GetKeyValuePair(type);
if (genericType == typeof(KeyValuePair <,>))
{
return(GenericType2.Get(type.GetGenericArguments()).JsonSerializeKeyValuePairMethod);
}
}
if ((methodInfo = GetCustom(type)) != null)
{
isCustom = type.IsValueType;
return(methodInfo);
}
return(GetIEnumerable(type) ?? GetType(type));
}
public ConfigurationModuleBuilder BindConstructor <T, U>(GenericType <T> clazz, GenericType <U> constructor)
where U : IExternalConstructor <T>
{
ConfigurationModuleBuilder c = DeepCopy();
try
{
c.B.BindConstructor <T, U>(clazz, constructor);
}
catch (BindException e)
{
Utilities.Diagnostics.Exceptions.Caught(e, Level.Error, LOGGER);
Utilities.Diagnostics.Exceptions.Throw(new ClassHierarchyException("Error in BindConstructor: ", e), LOGGER);
}
return(c);
}
static ITypeContainer CreateATypeConverterContainerGeneric(
Type SourceObjectType, Type SerializationType, object SerializedObject)
{
KeyValuePair <Type, Type> k = new KeyValuePair <Type, Type>(SerializationType, SourceObjectType);
Type g;
if (!GenericContainersTypeCache.TryGetValue(k, out g))
{
Type[] typeArgs = { SerializationType, SourceObjectType };
g = GenericType.MakeGenericType(typeArgs);
GenericContainersTypeCache.Add(k, g);
}
object o = Activator.CreateInstance(g, SerializedObject);
return(o as ITypeContainer);
}
public ConfigurationModuleBuilder BindList <U, T>(GenericType <U> iface, IList <string> impl)
where U : Name <IList <T> >
{
ConfigurationModuleBuilder c = DeepCopy();
try
{
ICsInternalConfigurationBuilder b = (ICsInternalConfigurationBuilder)c.B;
b.BindList(typeof(U), impl);
}
catch (BindException ex)
{
Utilities.Diagnostics.Exceptions.CaughtAndThrow(new ClassHierarchyException("Error in BindList: " + ex), Level.Error, LOGGER);
}
return(c);
}
/// <inheritdoc />
public override void Visit(GenericType genericType)
{
Write(genericType.Name).Write("<");
for (int i = 0; i < genericType.Parameters.Count; i++)
{
var parameter = genericType.Parameters[i];
if (i > 0)
{
Write(",").WriteSpace();
}
VisitDynamic(parameter);
}
Write(">");
}
public override void Visit(GenericType type)
{
if (IsTextureType(type))
{
Write("Texture");
}
else if (IsBufferType(type))
{
Write("Buffer");
}
else
{
base.Visit(type);
}
ProcessInitialValueStatus = false;
}
public ConfigurationModuleBuilder BindNamedParameter <U, T>(GenericType <U> name, string value)
where U : Name <T>
{
ConfigurationModuleBuilder c = DeepCopy();
try
{
c.B.BindNamedParameter <U, T>(name, value);
}
catch (BindException e)
{
Org.Apache.REEF.Utilities.Diagnostics.Exceptions.Caught(e, Level.Error, LOGGER);
Org.Apache.REEF.Utilities.Diagnostics.Exceptions.Throw(new ClassHierarchyException("Error in BindNamedParameter: ", e), LOGGER);
}
return(c);
}
public ConfigurationModuleBuilder BindImplementation <U, T>(GenericType <U> iface, GenericType <T> impl)
where T : U
{
ConfigurationModuleBuilder c = DeepCopy();
try
{
c.B.BindImplementation(iface, impl);
}
catch (BindException e)
{
Org.Apache.REEF.Utilities.Diagnostics.Exceptions.Caught(e, Level.Error, LOGGER);
Org.Apache.REEF.Utilities.Diagnostics.Exceptions.Throw(new ClassHierarchyException("Error in BindImplementation: ", e), LOGGER);
}
return(c);
}
protected virtual void Visit(GenericType <ObjectType> type)
{
if (IsTextureType(type))
{
Write("Texture");
}
else if (IsBufferType(type))
{
Write("Buffer");
}
else
{
Visit((GenericType)type);
}
ProcessInitialValueStatus = false;
}
public ConfigurationModuleBuilder BindNamedParameter <U, T>(GenericType <U> iface, GenericType <T> impl)
where U : Name <T>
{
ConfigurationModuleBuilder c = DeepCopy();
try
{
c.B.BindNamedParameter <U, T, T>(iface, impl);
}
catch (BindException e)
{
Utilities.Diagnostics.Exceptions.Caught(e, Level.Error, LOGGER);
Utilities.Diagnostics.Exceptions.Throw(new ClassHierarchyException("Error in BindNamedParameter: ", e), LOGGER);
}
return(c);
}
///// <summary>
///// object转换调用委托信息集合
///// </summary>
//private static readonly AutoCSer.Threading.LockDictionary<Type, Action<Serializer, object>> objectMethods = new AutoCSer.Threading.LockDictionary<Type, Action<Serializer, object>>();
///// <summary>
///// 字典转换函数信息
///// </summary>
//private static readonly MethodInfo serializeObjectMethod = typeof(Serializer).GetMethod("serializeObject", BindingFlags.Static | BindingFlags.NonPublic);
///// <summary>
///// 获取object转换调用委托信息
///// </summary>
///// <param name="type">真实类型</param>
///// <returns>object转换调用委托信息</returns>
//public static Action<Serializer, object> GetObject(Type type)
//{
// Action<Serializer, object> method;
// if (objectMethods.TryGetValue(type, out method)) return method;
// method = (Action<Serializer, object>)Delegate.CreateDelegate(typeof(Action<Serializer, object>), serializeObjectMethod.MakeGenericMethod(type));
// objectMethods.Set(type, method);
// return method;
//}
///// <summary>
///// 数组转换调用函数信息集合
///// </summary>
//private static readonly AutoCSer.Threading.LockDictionary<Type, MethodInfo> arrayMethods = new AutoCSer.Threading.LockDictionary<Type, MethodInfo>();
///// <summary>
///// 字典转换函数信息
///// </summary>
//private static readonly MethodInfo arrayMethod = typeof(Serializer).GetMethod("array", BindingFlags.Instance | BindingFlags.NonPublic);
///// <summary>
///// 获取数组转换委托调用函数信息
///// </summary>
///// <param name="type">数组类型</param>
///// <returns>数组转换委托调用函数信息</returns>
//public static MethodInfo GetArray(Type type)
//{
// MethodInfo method;
// if (arrayMethods.TryGetValue(type, out method)) return method;
// arrayMethods.Set(type, method = arrayMethod.MakeGenericMethod(type));
// return method;
//}
///// <summary>
///// 字典转换调用函数信息集合
///// </summary>
//private static readonly AutoCSer.Threading.LockDictionary<Type, MethodInfo> dictionaryMethods = new AutoCSer.Threading.LockDictionary<Type, MethodInfo>();
///// <summary>
///// 字典转换函数信息
///// </summary>
//private static readonly MethodInfo dictionaryMethod = typeof(Serializer).GetMethod("dictionary", BindingFlags.Instance | BindingFlags.NonPublic);
///// <summary>
///// 字符串字典转换函数信息
///// </summary>
//private static readonly MethodInfo stringDictionaryMethod = typeof(Serializer).GetMethod("stringDictionary", BindingFlags.Instance | BindingFlags.NonPublic);
/// <summary>
/// 获取字典转换委托调用函数信息
/// </summary>
/// <param name="type">枚举类型</param>
/// <returns>字典转换委托调用函数信息</returns>
public static MethodInfo GetDictionary(Type type)
{
Type[] types = type.GetGenericArguments();
if (types[0] == typeof(string))
{
return(GenericType.Get(types[1]).JsonSerializeStringDictionaryMethod);
}
return(GenericType2.Get(types).JsonSerializeDictionaryMethod);
//MethodInfo method;
//if (dictionaryMethods.TryGetValue(type, out method)) return method;
//Type[] types = type.GetGenericArguments();
//if (types[0] == typeof(string)) method = stringDictionaryMethod.MakeGenericMethod(types[1]);
//else method = dictionaryMethod.MakeGenericMethod(types);
//dictionaryMethods.Set(type, method);
//return method;
}
public ConfigurationModuleBuilder BindSetEntry <U, V, T>(GenericType <U> iface, GenericType <V> impl)
where U : Name <ISet <T> >
where V : T
{
ConfigurationModuleBuilder c = DeepCopy();
try
{
c.B.BindSetEntry <U, V, T>(iface, impl);
}
catch (BindException ex)
{
Utilities.Diagnostics.Exceptions.Caught(ex, Level.Error, LOGGER);
var e = new ClassHierarchyException("Error in BindSetEntry: " + ex);
Utilities.Diagnostics.Exceptions.Throw(e, LOGGER);
}
return(c);
}
public ConfigurationModuleBuilder BindSetEntry <U, T>(GenericType <U> iface, string impl)
where U : Name <ISet <T> >
{
ConfigurationModuleBuilder c = DeepCopy();
try
{
ICsInternalConfigurationBuilder b = (ICsInternalConfigurationBuilder)c.B;
b.BindSetEntry(typeof(U), impl);
}
catch (BindException ex)
{
Utilities.Diagnostics.Exceptions.Caught(ex, Level.Error, LOGGER);
var e = new ClassHierarchyException("Error in BindSetEntry: " + ex);
Utilities.Diagnostics.Exceptions.Throw(e, LOGGER);
}
return(c);
}
protected virtual void Visit(GenericType <ObjectType> type)
{
var typeName = type.Name.Text;
if (typeName.Contains("Texture"))
{
Write("Texture");
}
else if (typeName.Contains("Buffer"))
{
Write("Buffer");
}
else
{
Visit((GenericType)type);
}
ProcessInitialValueStatus = false;
}
public Generic(string encoded)
{
base.type = TokenType.Generic;
var split = encoded.Split(':');
var enumInt = int.Parse(split[0]);
if (split[1] == "-1")
identifier = string.Empty;
else
{
identifier = split[1];
if (identifier == "all")
allAlpha = true;
}
isCompound = bool.Parse(split[2]);
if (split[3] != "-1")
{
SetGenTypes(split[3]);
}
this.genericType = (GenericType)enumInt;
requiresClosure = bool.Parse(split[4]);
size = int.Parse(split[5]);
allowSymbols = bool.Parse(split[6]);
}
public void Method(GenericType<GenericType<int>> value)
{
}
public void Method(GenericType<ComplexType> value)
{
}
public void op_JsonSerialize_object_whenGenericValueType(string expected)
{
var example = new GenericType<int>
{
Value = 123
};
var actual = example.JsonSerialize();
Assert.Equal(expected, actual);
}
public void op_JsonSerialize_object_whenGenericReferenceTypeNull(string expected)
{
var example = new GenericType<AbsoluteUri>
{
Value = null
};
var actual = example.JsonSerialize();
Assert.Equal(expected, actual);
}
public void op_JsonSerialize_object_whenGenericNullableTypeDefault(string expected)
{
var example = new GenericType<int?>();
var actual = example.JsonSerialize();
Assert.Equal(expected, actual);
}
public static void Update(GenericType Type)
{
SqlCommand SQLCmd = new SqlCommand();
SQLCmd.CommandType = CommandType.StoredProcedure;
SQLCmd.CommandText = "UpdateTransportType";
SQLCmd.Parameters.Add("Id", SqlDbType.Int).Value = Type.Id;
SQLCmd.Parameters.Add("Name", SqlDbType.NVarChar, 100).Value = Type.Name;
BaseDataAccess.OpenConnection(SQLCmd);
BaseDataAccess.ExecuteNonSelect(SQLCmd);
BaseDataAccess.CloseConnection();
}
public Result(Statement statement, string answer, GenericType type)
{
}
/// <summary>
/// Checks the spacing of the tokens within the given generic type token.
/// </summary>
/// <param name="root">The document root.</param>
/// <param name="generic">The generic type token to check.</param>
private void CheckGenericSpacing(DocumentRoot root, GenericType generic)
{
Param.AssertNotNull(root, "root");
Param.AssertNotNull(generic, "generic");
// Make sure it contains at least one token.
if (generic.ChildTokens.Count > 0)
{
for (Node<CsToken> tokenNode = generic.ChildTokens.First; tokenNode != null; tokenNode = tokenNode.Next)
{
if (this.Cancel)
{
break;
}
// Check whether this token is a generic and if so parse the tokens within
// the generic statement.
if (tokenNode.Value.CsTokenClass == CsTokenClass.GenericType)
{
this.CheckGenericSpacing(root, tokenNode.Value as GenericType);
}
if (!tokenNode.Value.Generated)
{
switch (tokenNode.Value.CsTokenType)
{
case CsTokenType.Comma:
this.CheckSemicolonAndComma(root, generic.ChildTokens, tokenNode);
break;
case CsTokenType.OpenParenthesis:
this.CheckOpenParen(root, generic.ChildTokens, tokenNode);
break;
case CsTokenType.CloseParenthesis:
this.CheckCloseParen(root, generic.ChildTokens, tokenNode);
break;
case CsTokenType.OpenSquareBracket:
this.CheckOpenSquareBracket(root, generic.ChildTokens, tokenNode);
break;
case CsTokenType.CloseSquareBracket:
this.CheckCloseSquareBracket(root, generic.ChildTokens, tokenNode, true);
break;
case CsTokenType.WhiteSpace:
this.CheckWhitespace(root, tokenNode);
break;
case CsTokenType.OpenGenericBracket:
this.CheckGenericTokenOpenBracket(root, tokenNode);
break;
case CsTokenType.CloseGenericBracket:
this.CheckGenericTokenCloseBracket(root, tokenNode);
break;
case CsTokenType.PreprocessorDirective:
this.CheckPreprocessorSpacing(root, tokenNode.Value);
break;
case CsTokenType.OperatorSymbol:
OperatorSymbol symbol = tokenNode.Value as OperatorSymbol;
if (symbol.SymbolType == OperatorType.MemberAccess ||
symbol.SymbolType == OperatorType.QualifiedAlias)
{
this.CheckMemberAccessSymbol(root, generic.ChildTokens, tokenNode);
}
else
{
goto default;
}
break;
case CsTokenType.Other:
case CsTokenType.EndOfLine:
// Ignore these.
break;
default:
// There shouldn't be anything else within a generic type token.
Debug.Assert(false);
break;
}
}
}
}
}
public Variable(string variableName, string value, GenericType type)
{
this.type = type;
this.variableName = variableName;
this.value = value;
}
private static GenericType ParseGenericType(string normalizedName)
{
var curArg = new StringBuilder();
GenericType root = null;
GenericType curType = null;
// Func< Func<Func<int,int>,bool> >
// Func`1< Func`2< Func`2<System.Int32,System.Int32>, System.Boolean> >
// Func<int,bool,int>
for (var i = 0; i < normalizedName.Length; i++)
{
if (normalizedName[i] == '<')
{
if (curType == null)
{
curType = new GenericType(curArg.ToString(), null);
root = curType;
}
else
{
var newGeneric = new GenericType(curArg.ToString(), curType);
curType.Arguments.Add(newGeneric);
curType = newGeneric;
}
curArg.Length = 0;
}
else if (normalizedName[i] == '>')
{
if (curArg.Length > 0)
{
curType.Arguments.Add(new GenericType(TypeMapper.ShortToFull(curArg.ToString()), null));
}
if (curType.Parent != null)
{
curType = curType.Parent;
}
curArg.Length = 0;
}
else if (normalizedName[i] == ',')
{
if (curArg.Length > 0)
{
curType.Arguments.Add(new GenericType(TypeMapper.ShortToFull(curArg.ToString()), null));
}
curArg.Length = 0;
}
else
{
curArg.Append(normalizedName[i]);
}
}
return root;
}
public GenericType(string typeName, GenericType parent)
{
this.GenericTypeName = typeName;
var idx = typeName.IndexOf('`');
if (idx != -1)
{
this.GenericTypeName = typeName.Substring(0, idx);
}
this.Parent = parent;
}
private static void FormatExpandedGeneric(StringBuilder sb, GenericType type)
{
sb.Append(type.GenericTypeName);
if (type.Arguments.Count > 0)
{
sb.AppendFormat("`{0}", type.Arguments.Count);
sb.Append("<");
for (var i = 0; i < type.Arguments.Count; i++)
{
var curGen = type.Arguments[i];
if (curGen.Arguments.Count > 0)
{
FormatExpandedGeneric(sb, curGen);
}
else
{
sb.Append(curGen.GenericTypeName);
}
if (i != type.Arguments.Count - 1)
{
sb.Append(',');
}
}
sb.Append(">");
}
}
