ConstraintList.cs

Go to the documentation of this file.

// -------------------------------------------------------------------------- 
// Project rROTOR                                                             
// -------------------------------------------------------------------------- 
// File: ConstraintList.cs                                                    
// Author:  Francisco Ortin - francisco.ortin@gmail.com                       
// Description:                                                               
//    Composite class capable of representing a (possible empty) 
//        set of constraints.                     
//    Implements Composite pattern [Composite].                               
// -------------------------------------------------------------------------- 
// Create date: 05-04-2007                                                    
// Modification date: 05-04-2007                                              

using System;
using System.Collections.Generic;
using System.Text;
using ErrorManagement;

namespace TypeSystem.Constraints
{
    public class ConstraintList : Constraint
    {
        #region Fields
        private IList<Constraint> constraints = new List<Constraint>();
        #endregion

        #region Properties
        public IList<Constraint> Constraints
        {
            get { return this.constraints; }
        }

        public int Count
        {
            get { return constraints.Count; }
        }

        public Constraint this[int index]
        {
            get { return this.constraints[index]; }
        }


        #endregion

        #region BuildTypeExpressionString()
        protected override string BuildTypeExpressionString()
        {
            StringBuilder sb = new StringBuilder();
            for (int i = 0; i < this.constraints.Count; i++)
            {
                sb.Append(this.constraints[i].ToString());
                if (i < this.constraints.Count - 1)
                    sb.Append(", ");
            }
            return sb.ToString();
        }
        #endregion

        #region Add()
        public bool Add(Constraint constraint)
        {
            this.constraints.Add(constraint);
            return true;
        }
        #endregion

        #region isEmpty()
        public override bool isEmpty()
        {
            return this.constraints.Count == 0;
        }
        #endregion

        #region CloneTypeVariables()
        public override Constraint CloneTypeVariables(IDictionary<TypeVariable, TypeVariable> typeVariableMappings, IList<EquivalenceClass> equivalenceClasses)
        {
            ConstraintList newConstraint = new ConstraintList();
            foreach (Constraint constraint in this.constraints)
                newConstraint.Add(constraint.CloneTypeVariables(typeVariableMappings, equivalenceClasses));
            newConstraint.ValidTypeExpression = false;
            return newConstraint;
        }
        #endregion

        #region Check()
        public override TypeExpression Check(MethodType methodAnalyzed, TypeExpression actualImplicitObject, bool showInvocationMessage,
                        SortOfUnification activeSortOfUnification, Location location)
        {
            TypeExpression result = null;            
            foreach (Constraint constraint in this.constraints)            
                result = constraint.Check(methodAnalyzed, actualImplicitObject, showInvocationMessage, activeSortOfUnification, location);                            
            return result;
        }
        #endregion

    }
}