/// <summary>
/// Gets IP interfaces which are up
/// </summary>
private void GetInterfaces()
{
foreach (NetworkInterface networkInterface in NetworkInterface.GetAllNetworkInterfaces())
{
if (networkInterface.OperationalStatus == OperationalStatus.Up)
{
foreach (UnicastIPAddressInformation ip in networkInterface.GetIPProperties().UnicastAddresses)
{
if (ip.Address.AddressFamily == AddressFamily.InterNetwork)
{
InterfaceList.Add(new IPNetworkInterface
{
InterfaceAddress = ip.Address.ToString(),
InterfaceName = networkInterface.Name
});
}
}
}
}
if (InterfaceList.Count > 0)
{
SelectedInterface = InterfaceList[0];
}
else
{
selectedInterface = null;
}
RaisePropertyChanged("SelectedInterface");
}
private void RefreshInterfaceList()
{
// Retrieve the interfaces list
IList <LivePacketDevice> allDevices = LivePacketDevice.AllLocalMachine;
// Scan the list printing every entry
for (int i = 0; i < allDevices.Count(); i++)
{
InterfaceList.Add(allDevices[i]);
}
}
public void PopulateLists()
{
InterfaceList.Add(new DerivedIFaceA());
InterfaceList.Add(new DerivedIFaceB());
AbstractTypeList.Add(new DerivedAbstractA());
AbstractTypeList.Add(new DerivedAbstractB());
BaseTypeList.Add(new BaseType());
BaseTypeList.Add(new DerivedBaseA());
BaseTypeList.Add(new DerivedBaseB());
}
private ClassParameter ConvertToClassParameter(TypeNode typeParameter, InterfaceList interfaces, Class baseClass, ClassExpression cExpr)
{
ClassParameter cParam = typeParameter is MethodTypeParameter ? new MethodClassParameter() : new ClassParameter();
this.typeParamToClassParamMap[typeParameter.UniqueKey] = cParam;
cParam.SourceContext = typeParameter.SourceContext;
cParam.TypeParameterFlags = ((ITypeParameter)typeParameter).TypeParameterFlags;
if (typeParameter.IsUnmanaged)
{
cParam.SetIsUnmanaged();
}
cParam.Name = typeParameter.Name;
cParam.Namespace = StandardIds.ClassParameter;
cParam.BaseClass = baseClass == null ? SystemTypes.Object : baseClass;
cParam.BaseClassExpression = cExpr;
cParam.DeclaringMember = ((ITypeParameter)typeParameter).DeclaringMember;
cParam.DeclaringModule = typeParameter.DeclaringModule;
cParam.DeclaringType = typeParameter is MethodTypeParameter ? null : typeParameter.DeclaringType;
cParam.Flags = typeParameter.Flags & ~TypeFlags.Interface;
cParam.ParameterListIndex = ((ITypeParameter)typeParameter).ParameterListIndex;
MemberList mems = cParam.DeclaringType == null ? null : cParam.DeclaringType.Members;
int n = mems == null ? 0 : mems.Count;
for (int i = 0; i < n; i++)
{
if ((mems[i] as TypeNode) == typeParameter)
{
mems[i] = cParam;
break;
}
}
if (cExpr != null)
{
n = interfaces.Count - 1;
InterfaceList actualInterfaces = new InterfaceList(n);
for (int i = 0; i < n; i++)
{
actualInterfaces.Add(interfaces[i + 1]);
}
cParam.Interfaces = actualInterfaces;
}
else
{
cParam.Interfaces = interfaces;
}
if (cExpr != null)
{
cParam.BaseClass = this.VisitClassExpression(cExpr);
}
return(cParam);
}
/// <exception cref="ArgumentException">
/// The language of <paramref name="interfaceType"/> does not equal.-or-
/// <paramref name="interfaceType"/> is earlier implemented interface.
/// </exception>
/// <exception cref="ArgumentNullException">
/// <paramref name="interfaceType"/> is null.
/// </exception>
internal virtual void AddInterface(InterfaceType interfaceType)
{
if (interfaceType == null)
{
throw new ArgumentNullException("interfaceType");
}
for (int i = 0; i < InterfaceList.Count; i++)
{
if (InterfaceList[i] == interfaceType)
{
throw new ArgumentException("error_cannot_add_same_interface");
}
}
InterfaceList.Add(interfaceType);
}
/// <exception cref="RelationshipException">
/// The language of <paramref name="interfaceType" /> does not equal.-or-
/// <paramref name="interfaceType" /> is earlier implemented interface.
/// </exception>
/// <exception cref="ArgumentNullException">
/// <paramref name="interfaceType" /> is null.
/// </exception>
public virtual void AddInterface(InterfaceType interfaceType)
{
if (interfaceType == null)
{
throw new ArgumentNullException("interfaceType");
}
foreach (var implementedInterface in InterfaceList)
{
if (interfaceType == implementedInterface)
{
throw new RelationshipException(Strings.ErrorCannotAddSameInterface);
}
}
InterfaceList.Add(interfaceType);
Changed();
}
/// <exception cref="RelationException">
/// The language of <paramref name="interfaceType"/> does not equal.-or-
/// <paramref name="interfaceType"/> is earlier implemented interface.
/// </exception>
/// <exception cref="ArgumentNullException">
/// <paramref name="interfaceType"/> is null.
/// </exception>
public virtual void AddInterface(InterfaceType interfaceType)
{
if (interfaceType == null)
{
throw new ArgumentNullException("interfaceType");
}
foreach (InterfaceType implementedInterface in InterfaceList)
{
if (interfaceType == implementedInterface)
{
throw new RelationException(
Strings.GetString("error_cannot_add_same_interface"));
}
}
InterfaceList.Add(interfaceType);
Modified();
}
private ClassParameter ConvertToClassParameter(TypeNode typeParameter, InterfaceList interfaces, Class baseClass, ClassExpression cExpr){
ClassParameter cParam = typeParameter is MethodTypeParameter ? new MethodClassParameter() : new ClassParameter();
this.typeParamToClassParamMap[typeParameter.UniqueKey] = cParam;
cParam.SourceContext = typeParameter.SourceContext;
cParam.TypeParameterFlags = ((ITypeParameter)typeParameter).TypeParameterFlags;
if (typeParameter.IsUnmanaged) { cParam.SetIsUnmanaged(); }
cParam.Name = typeParameter.Name;
cParam.Namespace = StandardIds.ClassParameter;
cParam.BaseClass = baseClass == null ? SystemTypes.Object : baseClass;
cParam.BaseClassExpression = cExpr;
cParam.DeclaringMember = ((ITypeParameter)typeParameter).DeclaringMember;
cParam.DeclaringModule = typeParameter.DeclaringModule;
cParam.DeclaringType = typeParameter is MethodTypeParameter ? null : typeParameter.DeclaringType;
cParam.Flags = typeParameter.Flags & ~TypeFlags.Interface;
cParam.ParameterListIndex = ((ITypeParameter)typeParameter).ParameterListIndex;
MemberList mems = cParam.DeclaringType == null ? null : cParam.DeclaringType.Members;
int n = mems == null ? 0 : mems.Count;
for (int i = 0; i < n; i++){
if ((mems[i] as TypeNode) == typeParameter){
mems[i] = cParam;
break;
}
}
if (cExpr != null){
n = interfaces.Count - 1;
InterfaceList actualInterfaces = new InterfaceList(n);
for (int i = 0; i < n; i++)
actualInterfaces.Add(interfaces[i + 1]);
cParam.Interfaces = actualInterfaces;
}else
cParam.Interfaces = interfaces;
if (cExpr != null) cParam.BaseClass = this.VisitClassExpression(cExpr);
return cParam;
}
public virtual Differences VisitInterfaceReferenceList(InterfaceList list1, InterfaceList list2,
out InterfaceList changes, out InterfaceList deletions, out InterfaceList insertions){
changes = list1 == null ? null : list1.Clone();
deletions = list1 == null ? null : list1.Clone();
insertions = list1 == null ? new InterfaceList() : list1.Clone();
//^ assert insertions != null;
Differences differences = new Differences();
//Compare definitions that have matching key attributes
TrivialHashtable matchingPosFor = new TrivialHashtable();
TrivialHashtable matchedNodes = new TrivialHashtable();
for (int j = 0, n = list2 == null ? 0 : list2.Count; j < n; j++){
//^ assert list2 != null;
Interface nd2 = list2[j];
if (nd2 == null || nd2.Name == null) continue;
matchingPosFor[nd2.Name.UniqueIdKey] = j;
insertions.Add(null);
}
for (int i = 0, n = list1 == null ? 0 : list1.Count; i < n; i++){
//^ assert list1 != null && changes != null && deletions != null;
Interface nd1 = list1[i];
if (nd1 == null || nd1.Name == null) continue;
object pos = matchingPosFor[nd1.Name.UniqueIdKey];
if (!(pos is int)) continue;
//^ assert pos != null;
//^ assume list2 != null; //since there was entry int matchingPosFor
int j = (int)pos;
Interface nd2 = list2[j];
//nd1 and nd2 have the same key attributes and are therefore treated as the same entity
matchedNodes[nd1.UniqueKey] = nd1;
//^ assume nd2 != null;
matchedNodes[nd2.UniqueKey] = nd2;
//nd1 and nd2 may still be different, though, so find out how different
Differences diff = this.VisitInterface(nd1, nd2);
if (diff == null){Debug.Assert(false); continue;}
if (diff.NumberOfDifferences != 0){
changes[i] = diff.Changes as Interface;
deletions[i] = diff.Deletions as Interface;
insertions[i] = diff.Insertions as Interface;
insertions[n+j] = nd1; //Records the position of nd2 in list2 in case the change involved a permutation
//Debug.Assert(diff.Changes == changes[i] && diff.Deletions == deletions[i] && diff.Insertions == insertions[i]);
differences.NumberOfDifferences += diff.NumberOfDifferences;
differences.NumberOfSimilarities += diff.NumberOfSimilarities;
continue;
}
changes[i] = null;
deletions[i] = null;
insertions[i] = null;
insertions[n+j] = nd1; //Records the position of nd2 in list2 in case the change involved a permutation
}
//Find deletions
for (int i = 0, n = list1 == null ? 0 : list1.Count; i < n; i++){
//^ assert list1 != null && changes != null && deletions != null;
Interface nd1 = list1[i];
if (nd1 == null) continue;
if (matchedNodes[nd1.UniqueKey] != null) continue;
changes[i] = null;
deletions[i] = nd1;
insertions[i] = null;
differences.NumberOfDifferences += 1;
}
//Find insertions
for (int j = 0, n = list1 == null ? 0 : list1.Count, m = list2 == null ? 0 : list2.Count; j < m; j++){
//^ assert list2 != null;
Interface nd2 = list2[j];
if (nd2 == null) continue;
if (matchedNodes[nd2.UniqueKey] != null) continue;
insertions[n+j] = nd2; //Records nd2 as an insertion into list1, along with its position in list2
differences.NumberOfDifferences += 1; //REVIEW: put the size of the tree here?
}
if (differences.NumberOfDifferences == 0){
changes = null;
deletions = null;
insertions = null;
}
return differences;
}
/// <summary>
/// Computes an upper bound in the type hierarchy for the set of argument types.
/// This upper bound is a type that all types in the list are assignable to.
/// If the types are all classes, then *the* least-upper-bound in the class
/// hierarchy is returned.
/// If the types contain at least one interface, then *a* deepest upper-bound
/// is found from the intersection of the upward closure of each type.
/// Note that if one of the types is System.Object, then that is immediately
/// returned as the unified type without further examination of the list.
/// </summary>
/// <param name="ts">A list containing the set of types from which to compute the unified type.</param>
/// <returns>The type corresponding to the least-upper-bound.</returns>
public virtual TypeNode UnifiedType(TypeNodeList ts, TypeViewer typeViewer){
if (ts == null || ts.Count == 0) return null;
TypeNode unifiedType = SystemTypes.Object; // default unified type
bool atLeastOneInterface = false;
#region If at least one of the types is System.Object, then that is the unified type
for (int i = 0, n = ts.Count; i < n; i++){
TypeNode t = this.Unwrap(ts[i]);
if (t == SystemTypes.Object){
return SystemTypes.Object;
}
}
#endregion If at least one of the types is System.Object, then that is the unified type
// assert forall{TypeNode t in ts; t != SystemTypes.Object};
#region See if any of the types are interfaces
for (int i = 0, n = ts.Count; i < n; i++){
TypeNode t = this.Unwrap(ts[i]);
if (t.NodeType == NodeType.Interface){
atLeastOneInterface = true;
break;
}
}
#endregion See if any of the types are interfaces
#region Find the LUB in the class hierarchy (if there are no interfaces)
if (!atLeastOneInterface){
TrivialHashtable h = new TrivialHashtable(ts.Count);
// Create the list [s, .., t] for each element t of ts where for each item
// in the list, t_i, t_i = t_{i+1}.BaseType. (s.BaseType == SystemTypes.Object)
// Store the list in a hashtable keyed by t.
// Do this only for classes. Handle interfaces in a different way because of
// multiple inheritance.
for (int i = 0, n = ts.Count; i < n; i++){
TypeNodeList tl = new TypeNodeList();
TypeNode t = this.Unwrap(ts[i]);
tl.Add(t);
TypeNode t2 = t.BaseType;
while (t2 != null && t2 != SystemTypes.Object){ // avoid including System.Object in the list for classes
tl.Insert(t2,0);
t2 = this.Unwrap(t2.BaseType);
}
h[ts[i].UniqueKey] = tl;
}
bool stop = false;
int depth = 0;
while (!stop){
TypeNode putativeUnifiedType = null;
int i = 0;
int n = ts.Count;
putativeUnifiedType = ((TypeNodeList) h[ts[0].UniqueKey])[depth];
while (i < n){
TypeNode t = ts[i];
TypeNodeList subTypes = (TypeNodeList) h[t.UniqueKey];
if (subTypes.Count <= depth || subTypes[depth] != putativeUnifiedType){
// either reached the top of the hierarchy for t_i or it is on a different branch
// than the current one.
stop = true;
break;
}
i++;
}
if (i == n){ // made it all the way through: all types are subtypes of the current one
unifiedType = putativeUnifiedType;
}
depth++;
}
}
#endregion Find the LUB in the class hierarchy (if there are no interfaces)
#region Find *a* LUB in the interface hierarchy (if there is at least one interface or current LUB is object)
if (unifiedType == SystemTypes.Object || atLeastOneInterface){
TrivialHashtable interfaces = new TrivialHashtable();
for (int i = 0, n = ts.Count; i < n; i++){
InterfaceList il = new InterfaceList();
interfaces[ts[i].UniqueKey] = il;
this.SupportedInterfaces(ts[i],il,typeViewer); // side-effect: il gets added to
}
// interfaces[ts[i]] is the upward closure of all of the interfaces supported by ts[i]
// compute the intersection of all of the upward closures
// might as well start with the first type in the list ts
InterfaceList intersection = new InterfaceList();
InterfaceList firstIfaceList = (InterfaceList)interfaces[ts[0].UniqueKey];
for (int i = 0, n = firstIfaceList.Count; i < n; i++){
Interface iface = firstIfaceList[i];
bool found = false;
int j = 1; // start at second type in the list ts
while (j < ts.Count){
InterfaceList cur = (InterfaceList)interfaces[ts[j].UniqueKey];
found = false;
for (int k = 0, p = cur.Count; k < p; k++){
if (cur[k] == iface){
found = true;
break;
}
}
if (!found){
// then the j-th type doesn't support iface, don't bother looking in the rest
break;
}
j++;
}
if (found){
intersection.Add(iface);
}
}
// TODO: take the "deepest" interface in the intersection.
// "deepest" means that if any other type in the intersection is a subtype
// of it, then *don't* consider it.
if (intersection.Count > 0){
InterfaceList finalIntersection = new InterfaceList(intersection.Count);
Interface iface = intersection[0];
for (int i = 0, n = intersection.Count; i < n; i++){
Interface curFace = intersection [i];
int j = 0;
int m = intersection.Count;
while (j < m){
if (j != i){
Interface jFace = intersection[j];
if (TypeViewer.GetTypeView(typeViewer, jFace).IsAssignableTo(curFace))
break;
}
j++;
}
if (j == m){ // made it all the way through, no other iface is a subtype of curFace
finalIntersection.Add(curFace);
}
}
if (finalIntersection.Count > 0){
unifiedType = finalIntersection[0]; // heuristic: just take the first one
}
}
}
#endregion Find *a* LUB in the interface hierarchy (if there is at least one interface or current LUB is object)
return unifiedType;
}
public virtual void SupportedInterfaces(TypeNode t, InterfaceList ifaceList, TypeViewer typeViewer){
if (ifaceList == null) return;
TypeNode unwrappedT = this.Unwrap(t);
Interface iface = unwrappedT as Interface;
if (iface != null){
// possibly not needed, but seems better to keep ifaceList as a set
int i = 0;
while (i < ifaceList.Count){
if (ifaceList[i] == iface)
break;
i++;
}
if (i == ifaceList.Count) // not found
ifaceList.Add(iface);
}else{
// nop
}
InterfaceList ifaces = TypeViewer.GetTypeView(typeViewer, unwrappedT).Interfaces;
for (int i = 0, n = ifaces == null ? 0 : ifaces.Count; i < n; i++){
this.SupportedInterfaces(ifaces[i],ifaceList,typeViewer);
}
return;
}
private InterfaceList ParseInterfaceList(TokenSet followers, bool expectLeftBrace){
InterfaceList ilist = new InterfaceList();
TokenSet followersOrComma = followers|Token.Comma;
for(;;){
Expression id = this.scanner.GetIdentifier();
switch(this.currentToken){
case Token.Bool:
case Token.Decimal:
case Token.Sbyte:
case Token.Byte:
case Token.Short:
case Token.Ushort:
case Token.Int:
case Token.Uint:
case Token.Long:
case Token.Ulong:
case Token.Char:
case Token.Float:
case Token.Double:
case Token.Object:
case Token.String:
case Token.Void:
TypeExpression texpr = this.TypeExpressionFor(this.currentToken);
this.GetNextToken();
ilist.Add(new InterfaceExpression(texpr.Expression, texpr.SourceContext));
goto lookForComma;
default:
bool idOK = Parser.IdentifierOrNonReservedKeyword[this.currentToken];
if (idOK){
this.GetNextToken();
if (this.currentToken == Token.DoubleColon){
this.GetNextToken();
Identifier id2 = this.scanner.GetIdentifier();
id2.Prefix = (Identifier)id;
id2.SourceContext.StartPos = id.SourceContext.StartPos;
this.SkipIdentifierOrNonReservedKeyword();
id = id2;
}
if (this.currentToken == Token.Dot)
id = this.ParseQualifiedIdentifier(id, followersOrComma|Token.LessThan);
}else{
int col = this.scanner.endPos;
this.SkipIdentifierOrNonReservedKeyword(Error.TypeExpected);
if (col == this.scanner.endPos && this.currentToken != Token.EndOfFile){
//Did not consume a token, but just gave an error
if (!followersOrComma[this.currentToken]) this.GetNextToken();
if (followers[this.currentToken]) return ilist;
if (this.currentToken != Token.Comma){
if (Parser.IdentifierOrNonReservedKeyword[this.currentToken]) continue;
break;
}
this.GetNextToken();
continue;
}
if (this.currentToken == Token.Dot)
id = this.ParseQualifiedIdentifier(id, followersOrComma|Token.LessThan);
if (!idOK) goto lookForComma;
}
break;
}
//I really want an Identifier here for StartName
if (this.sink != null) {
Identifier name = id as Identifier;
if (id is QualifiedIdentifier) {
name = ((QualifiedIdentifier)id).Identifier;
}
if (name != null) {
this.sink.StartName(name);
}
}
InterfaceExpression ifaceExpr = new InterfaceExpression(id, id.SourceContext);
if (this.currentToken == Token.LessThan){
yetAnotherTypeArgumentList:
this.GetNextToken();
TypeNodeList arguments = new TypeNodeList();
for(;;){
TypeNode t = this.ParseTypeExpression(null, followers|Token.Comma|Token.GreaterThan);
arguments.Add(t);
if (this.currentToken != Token.Comma) break;
this.GetNextToken();
}
ifaceExpr.TemplateArguments = arguments;
ifaceExpr.TemplateArgumentExpressions = arguments.Clone();
ifaceExpr.SourceContext.EndPos = this.scanner.endPos;
this.Skip(Token.GreaterThan);
if (this.currentToken == Token.Dot) {
TemplateInstance tempInst = new TemplateInstance(ifaceExpr.Expression, ifaceExpr.TemplateArguments);
tempInst.TypeArgumentExpressions = ifaceExpr.TemplateArguments == null ? null : ifaceExpr.TemplateArguments.Clone();
tempInst.SourceContext = ifaceExpr.SourceContext;
ifaceExpr.Expression = this.ParseQualifiedIdentifier(tempInst, followersOrComma|Token.LessThan);
ifaceExpr.TemplateArguments = null;
ifaceExpr.TemplateArgumentExpressions = null;
if (ifaceExpr.Expression != null) ifaceExpr.SourceContext = ifaceExpr.Expression.SourceContext;
if (this.currentToken == Token.LessThan) goto yetAnotherTypeArgumentList;
}
}
ilist.Add(ifaceExpr);
lookForComma:
if (Parser.TypeOperator[this.currentToken] && !(expectLeftBrace && this.currentToken == Token.LeftBrace)){
this.HandleError(Error.BadBaseType);
this.GetNextToken();
if (this.currentToken == Token.RightBracket || this.currentToken == Token.RightBrace)
this.GetNextToken();
this.SkipTo(followersOrComma, Error.None);
}else if (!followersOrComma[this.currentToken])
this.SkipTo(followersOrComma, Error.TypeExpected);
if (this.currentToken == Token.Comma){
if (followers[Token.Comma] && followers[Token.GreaterThan])
break; //Parsing the constraint of a type parameter
this.GetNextToken();
if (expectLeftBrace && (this.currentToken == Token.Class || this.currentToken == Token.Struct || this.currentToken == Token.New))
break;
}else if (!Parser.TypeStart[this.currentToken] || this.currentToken == Token.Where)
break;
else if (Parser.ContractStart[this.currentToken])
break;
}
return ilist;
}
private InterfaceList TranslateToInterfaceList(CodeTypeReferenceCollection interfaces){
int n = interfaces == null ? 0 : interfaces.Count;
InterfaceList interfaceList = new InterfaceList(n);
for (int i = 0; i < n; i++)
interfaceList.Add(this.TranslateToInterface(interfaces[i]));
return interfaceList;
}
private InterfaceList FindMatchingInterfaces(Class c, ZMethod zMethod)
{
InterfaceList matches = new InterfaceList(1);
if (c.Interfaces != null && c.Interfaces.Count > 0)
{
for (int i = 0; i < c.Interfaces.Count; i++)
{
Interface x = c.Interfaces[i];
if (x.GetMatchingMethod(zMethod) != null)
matches.Add(x);
}
}
return matches;
}
private void GetInterfaces(int i, int firstInterfaceIndex, InterfaceList/*!*/ interfaces)
{
InterfaceImplRow[] intfaces = this.tables.InterfaceImplTable;
for (int j = firstInterfaceIndex, n = intfaces.Length; j < n; j++)
{
if (intfaces[j].Class != i) continue; //TODO: break if sorted
TypeNode ifaceT = this.DecodeAndGetTypeDefOrRefOrSpec(intfaces[j].Interface);
Interface iface = ifaceT as Interface;
if (iface == null)
{
iface = new Interface();
if (ifaceT != null)
{
iface.DeclaringModule = ifaceT.DeclaringModule;
iface.Namespace = ifaceT.Namespace;
iface.Name = ifaceT.Name;
}
}
interfaces.Add(iface);
}
}
private void GetGenericParameterConstraints(int index, ref TypeNode/*!*/ parameter)
{
Debug.Assert(parameter != null);
index++;
GenericParamConstraintRow[] genericParameterConstraints = this.tables.GenericParamConstraintTable;
TypeNodeList constraints = new TypeNodeList();
Class baseClass = null;
InterfaceList interfaces = new InterfaceList();
int i = 0, n = genericParameterConstraints.Length, j = n - 1;
bool sorted = (this.sortedTablesMask >> (int)TableIndices.GenericParamConstraint) % 2 == 1;
if (sorted)
{
while (i < j)
{
int k = (i + j) / 2;
if (genericParameterConstraints[k].Param < index)
i = k + 1;
else
j = k;
}
while (i > 0 && genericParameterConstraints[i - 1].Param == index) i--;
}
for (; i < n; i++)
{
if (genericParameterConstraints[i].Param == index)
{
TypeNode t = this.DecodeAndGetTypeDefOrRefOrSpec(genericParameterConstraints[i].Constraint);
Class c = t as Class;
if (c != null)
baseClass = c;
else if (t is Interface)
interfaces.Add((Interface)t);
constraints.Add(t);
}
else if (sorted)
break;
}
ClassParameter cp = parameter as ClassParameter;
if (cp == null && baseClass != null)
{
cp = ((ITypeParameter)parameter).DeclaringMember is Method ? new MethodClassParameter() : new ClassParameter();
cp.Name = parameter.Name;
cp.DeclaringMember = ((ITypeParameter)parameter).DeclaringMember;
cp.ParameterListIndex = ((ITypeParameter)parameter).ParameterListIndex;
cp.DeclaringModule = this.module;
cp.TypeParameterFlags = ((ITypeParameter)parameter).TypeParameterFlags;
parameter = cp;
}
if (cp != null)
cp.structuralElementTypes = constraints;
else
((TypeParameter)parameter).structuralElementTypes = constraints;
if (baseClass != null && cp != null) cp.BaseClass = baseClass;
parameter.Interfaces = interfaces;
}
public virtual void VisitBaseClassReference(Class Class){
if (Class == null) return;
if (Class.Name.UniqueIdKey == StandardIds.CapitalObject.UniqueIdKey && Class.Namespace.UniqueIdKey == StandardIds.System.UniqueIdKey) {
Class.BaseClass = null; Class.BaseClassExpression = null;
return;
}
if (Class.PartiallyDefines is Class && ((Class)Class.PartiallyDefines).BaseClass == null)
this.VisitBaseClassReference((Class)Class.PartiallyDefines);
TypeNodeList partialTypes = Class.IsDefinedBy;
if (partialTypes != null){
for (int i = 0, n = partialTypes == null ? 0 : partialTypes.Count; i < n; i++){
Class partialClass = partialTypes[i] as Class;
if (partialClass == null || partialClass.BaseClass == SystemTypes.Object) continue;
partialClass.PartiallyDefines = null; //Stop recursion
this.VisitBaseClassReference(partialClass);
partialClass.PartiallyDefines = Class;
if (partialClass.BaseClass == SystemTypes.Object) continue;
Class.BaseClass = partialClass.BaseClass;
return;
}
}
//Visit Class.BaseClass, but guard against doing it twice
//(this routine can get called when visiting a derived class that occurs lexically before Class)
if (Class.BaseClassExpression == Class) return; //Still resolving the base class. This is a recursive call due to a recursive type argument.
if (Class.BaseClass != null) {
ClassExpression cExpr = Class.BaseClass as ClassExpression;
if (cExpr == null) return; //Been here before and found a base class
this.VisitBaseClassReference(Class, true);
return;
}
//Leaving the BaseClass null is the convention for asking that the first expression in the interface list be treated as the base class, if possible.
//If not possible, the convention is to set BaseClass equal to SystemTypes.Object.
InterfaceList interfaces = Class.Interfaces;
InterfaceList interfaceExpressions = Class.InterfaceExpressions;
if (interfaces != null && interfaces.Count > 0){
Interface iface = interfaces[0];
InterfaceExpression ifExpr = iface as InterfaceExpression;
if (ifExpr != null){
ClassExpression cExpr = new ClassExpression(ifExpr.Expression, ifExpr.TemplateArguments, ifExpr.SourceContext);
Class.BaseClass = Class.BaseClassExpression = cExpr;
if (this.VisitBaseClassReference(Class, false)){
//The first expression is not meant as an interface, remove it from the list
int n = interfaces.Count-1;
InterfaceList actualInterfaces = new InterfaceList(n);
InterfaceList actualInterfaceExpressions = new InterfaceList(n);
for (int i = 0; i < n; i++) {
actualInterfaces.Add(interfaces[i+1]);
if (interfaceExpressions != null)
actualInterfaceExpressions.Add(interfaceExpressions[i+1]);
}
Class.Interfaces = actualInterfaces;
if (interfaceExpressions != null)
Class.InterfaceExpressions = actualInterfaceExpressions;
}else{
Class.BaseClass = SystemTypes.Object; Class.BaseClassExpression = null;
}
}else{
Class.BaseClass = SystemTypes.Object; Class.BaseClassExpression = null;
}
}else{
Class.BaseClass = SystemTypes.Object; Class.BaseClassExpression = null;
}
if (Class.BaseClass != null && Class.BaseClass != SystemTypes.Object) {
this.VisitBaseClassReference(Class.BaseClass.Template as Class);
this.VisitBaseClassReference(Class.BaseClass);
}
}
/// <summary>
/// 注册需要的接口实现
/// </summary>
/// <typeparam name="T">接口</typeparam>
/// <typeparam name="TK">实现类</typeparam>
public void Register <T, TK>() where T : class where TK : T
{
ObjectContainer.Register(Castle.MicroKernel.Registration.
Component.For <T>().ImplementedBy <TK>());
InterfaceList.Add(typeof(T));
}
