UserType.cs

Go to the documentation of this file.

// -------------------------------------------------------------------------- //
// Project rROTOR                                                             //
// -------------------------------------------------------------------------- //
// File: UserType.cs                                                          //
// Authors: Cristina Gonzalez Muñoz  -  cristi.gm@gmail.com                   //
//          Francisco Ortin - francisco.ortin@gmail.com                       //
// Description:                                                               //
//    Represents a class or interface type.                                   //
//    Inheritance: TypeExpression.                                            //
//    Implements Composite pattern [Composite].                               //
// -------------------------------------------------------------------------- //
// Create date: 26-01-2007                                                    //
// Modification date: 29-01-2007                                              //
//visto
using System;
using System.Collections.Generic;

using ErrorManagement;
using TypeSystem.Operations;

namespace TypeSystem {
    public abstract class UserType : TypeExpression {
        #region Fields

        private Dictionary<string, AccessModifier> memberList = new Dictionary<string, AccessModifier>();

        protected Dictionary<string, AccessModifier> fieldList = new Dictionary<string, AccessModifier>();

        private AccessModifier constructorList;

        private Dictionary<string, AccessModifier> methodList = new Dictionary<string, AccessModifier>();

        protected List<InterfaceType> interfaceList;

        protected List<Modifier> modifierList;

        protected Modifier modifierMask;

        protected string name;

        #endregion

        #region Properties

        public Dictionary<string, AccessModifier> Fields {
            get { return this.fieldList; }
        }

        public AccessModifier Constructors {
            get { return this.constructorList; }
        }

        public Dictionary<string, AccessModifier> Methods {
            get { return this.methodList; }
        }

        public Dictionary<string, AccessModifier> Members {
            get { return this.memberList; }
            set {
                this.memberList = value;
                foreach (KeyValuePair<string, AccessModifier> pair in value) {
                    TypeExpression memberType = pair.Value.Type;
                    if (memberType is FieldType)
                        fieldList[pair.Key] = pair.Value;
                    else if (pair.Key.Equals(pair.Value.Class.Name)||pair.Key.Equals(pair.Value.Class.FullName))
                        if (this.constructorList != null)
                            System.Diagnostics.Debug.Assert(false, "Use intersection types for multiple constructors.");
                        else this.constructorList = pair.Value;
                    else
                        methodList[pair.Key] = pair.Value;
                }
            }
        }


        public List<Modifier> Modifiers {
            set {
                for (int i = 0; i < value.Count; i++) {
                    this.modifierMask |= value[i];
                }
                if ((this.modifierMask & Modifier.AccessLevel) == 0) {
                    value.Add(Modifier.Internal);
                    this.modifierMask |= Modifier.Internal;
                }
                this.modifierList = value;
            }
        }

        public string Name {
            get { return this.name; }
        }

       public Modifier ModifierMask
       {
          get { return this.modifierMask; }
       }

       public List<InterfaceType> InterfaceList
       {
          get { return this.interfaceList; }
       }
       
        #endregion

        #region Constructor

        protected UserType(string identifier) {
            this.fullName = identifier;
            this.interfaceList = new List<InterfaceType>();
        }

        #endregion

        #region Dispatcher
        public override object AcceptOperation(TypeSystemOperation op, object arg) { return op.Exec(this, arg); }
        #endregion

        #region AddMember()
        public void AddMember(string name, AccessModifier accessModifier) {
            TypeExpression memberType = accessModifier.Type;
            memberList[name] = accessModifier;
            if (memberType is FieldType)
                fieldList[name] = accessModifier;
            else if (memberType is MethodType && name.Equals(accessModifier.Class.Name))
                if (this.constructorList != null)
                    System.Diagnostics.Debug.Assert(false, "Use intersection types for multiple constructors.");
                else this.constructorList = accessModifier;
            else
                methodList[name] = accessModifier;
        }
        #endregion

        #region AddBaseClass()
        public abstract void AddBaseClass(ClassType inheritedType, Location location);
        #endregion

        #region AddBaseInterface()
        public void AddBaseInterface(InterfaceType inheritedType, Location location) {
                this.interfaceList.Add((InterfaceType)inheritedType);
        }
        #endregion

        #region HasTypeVariables()
        public override bool HasTypeVariables() {
            return HasTypeVariables(new List<String>());
        }

        public bool HasTypeVariables(IList<String> evaluated)
        {
            if (this.validHasTypeVariables)
                return this.hasTypeVariablesCache;
            bool toReturn = false;
            foreach (AccessModifier am in this.Fields.Values)
            {                
                if (evaluated.Contains(am.Type.FullName))
                    continue;
                else
                {
                    evaluated.Add(am.Type.FullName);
                    bool result;
                    if (am.Type is FieldType)
                        result = ((FieldType)am.Type).HasTypeVariables(evaluated);
                    else
                        result = am.Type.HasTypeVariables();                                       
                    if (result)                    
                        toReturn = true;                    
                }
                if (toReturn)
                    break;
            }
            this.validHasTypeVariables = true;
            return this.hasTypeVariablesCache = toReturn;
        }
        #endregion

        #region InheritsFrom()
        public virtual bool InheritsFrom(UserType superType) {
            // * A class does not inherit from itself
            if ((bool)this.AcceptOperation(new EquivalentOperation(superType), null))
                return false;
            // * Depth first search
            foreach (InterfaceType interfaze in this.interfaceList)
                if (interfaze == superType || (bool)interfaze.AcceptOperation(new EquivalentOperation(superType), null))
                    return true;
            foreach (InterfaceType interfaze in this.interfaceList)
                if (interfaze.InheritsFrom(superType))
                    return true;
            // * No inheritance
            return false;
        }
        #endregion

    }
}