AccessModifier.cs

Go to the documentation of this file.

// -------------------------------------------------------------------------- //
// Project rROTOR                                                             //
// -------------------------------------------------------------------------- //
// File: AccessModifier.cs                                                    //
// Authors: Cristina Gonzalez Muñoz  -  cristi.gm@gmail.com                   //
//          Francisco Ortin - francisco.ortin@gmail.com                       //
// Description:                                                               //
//    Association Class between ClassType and MethodType (or Fields).         //
//    Represents the access modifier infomation about a concrete attribute and   //
// its class.                                                                 //
// -------------------------------------------------------------------------- //
// Create date: 22-10-2006                                                    //
// Modification date: 18-04-2007                                              //

using System;
using System.Diagnostics;
using System.Collections.Generic;
using System.Text; 

using AST;
using TypeSystem.Operations;
//viSto0
namespace TypeSystem
{
   #region Modifier

   public enum Modifier
   {
      Public = 2,
      Protected = 4,
      Internal = 8,
      Private = 16,
      Static = 32,
      Abstract = 64,
      New = 128,
      Override = 256,
      Virtual = 512,
      AccessLevel = Public | Protected | Private | Internal,
      CanRead = 1024,
      CanWrite = 2048,
   }

   #endregion

   public class AccessModifier : ICloneable
   {
      #region Fields

      private UserType classType;

      private IMemberType type;

      private List<Modifier> modifierList;

      private Modifier modifierMask;

      private string id;

      #endregion

      #region Properties

      public TypeExpression Type
      {
         get
         {
            System.Diagnostics.Debug.Assert(type==null || type is IMemberType, "The type must be a TypeExpression");
            return (TypeExpression)type;
         }
         set
         {
            System.Diagnostics.Debug.Assert(value is IMemberType, "The type must implement IMemberType");
            type = (IMemberType)value;
         }
      }

      public UserType Class
      {
         get { return this.classType; }
         set { this.classType = value; }
      }

      public string MemberIdentifier
      {
         get { return this.id; }
      }

      public List<Modifier> Modifiers
      {
         get { return this.modifierList; }
      }

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

      #endregion

      #region Constructor

      public AccessModifier(List<Modifier> mods, string idMember, IMemberType memberType, bool interfaceMember)
      {
         for (int i = 0; i < mods.Count; i++)
         {
            this.modifierMask |= mods[i];
         }

         if (!interfaceMember)
         {
            if ((this.modifierMask & Modifier.AccessLevel) == 0)
            {
               mods.Add(Modifier.Private);
               this.modifierMask |= Modifier.Private;
            }
         }

         this.modifierList = mods;
         this.type = memberType;
         this.id = idMember;
      }
      #endregion
      
      #region Dispatcher
      //public override object AcceptOperation(TypeSystemOperation op) { return op.AcceptOperation(this); }
      #endregion

      #region hasModifier()
      public bool hasModifier(Modifier mod)
      {
         if ((this.modifierMask & mod) != 0)
            return true;

         for (int i = 0; i < this.modifierList.Count; i++)
            if ((this.modifierList[i] & mod) != 0)
               return true;
         return false;
      }
      #endregion

      #region Clone()
      public Object Clone()
      {
         return this.MemberwiseClone();
      }
      #endregion
   }
}