AspectSharp/AspectSharp.Lang/AST/MethodSignature.cs

   1  // Copyright 2004-2008 Castle Project - http://www.castleproject.org/
   2 //
   3 // Licensed under the Apache License, Version 2.0 (the "License");
   4 // you may not use this file except in compliance with the License.
   5 // You may obtain a copy of the License at
   6 //
   7 //     http://www.apache.org/licenses/LICENSE-2.0
   8 //
   9 // Unless required by applicable law or agreed to in writing, software
  10 // distributed under the License is distributed on an "AS IS" BASIS,
  11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 // See the License for the specific language governing permissions and
  13 // limitations under the License.
  14
  15 namespace AspectSharp.Lang.AST
  16 {
  17         using System;
  18         using System.Collections;
  19
  20         /// <summary>
  21         /// Summary description for MethodSignature.
  22         /// </summary>
  23         [Serializable]
  24         public class MethodSignature
  25         {
  26                 protected static readonly String ALL_MARK = "*";
  27
  28                 private string _access = string.Empty;
  29                 private String _retType = String.Empty;
  30                 private String _methodName = String.Empty;
  31                 private ArrayList _arguments = new ArrayList();
  32                 private bool _allAccess = false;
  33                 private bool _allRetTypes = false;
  34                 private bool _allArguments = false;
  35
  36                 protected MethodSignature()
  37                 {
  38                 }
  39
  40                 public MethodSignature(String retType, String methodName)
  41                         : this("*", retType, methodName)
  42                 {
  43                 }
  44
  45                 public MethodSignature(String access, String retType, String methodName)
  46                 {
  47                         if (ALL_MARK.EndsWith(access))
  48                         {
  49                                 _allAccess = true;
  50                         }
  51                         if (ALL_MARK.Equals(retType))
  52                         {
  53                                 _allRetTypes = true;
  54                         }
  55                         _access = String.Intern(access.ToLower());
  56                         _retType = String.Intern(retType.ToLower());
  57                         _methodName = String.Intern(methodName);
  58                 }
  59
  60                 public void AddArgumentType(String typeName)
  61                 {
  62                         if ( _arguments.Count == 0 && ALL_MARK.Equals(typeName))
  63                         {
  64                                 _allArguments = true;
  65                         }
  66                         else
  67                         {
  68                                 _allArguments = false;
  69                         }
  70                         _arguments.Add(String.Intern(typeName.ToLower()));
  71                 }
  72
  73                 public string Access
  74                 {
  75                         get
  76                         {
  77                                 return _access;
  78                         }
  79                 }
  80
  81                 public String RetType
  82                 {
  83                         get { return _retType; }
  84                 }
  85
  86                 public String MethodName
  87                 {
  88                         get { return _methodName; }
  89                 }
  90
  91                 public String[] Arguments
  92                 {
  93                         get { return (String[]) _arguments.ToArray(typeof (String)); }
  94                 }
  95
  96                 public bool AllAccess
  97                 {
  98                         get { return _allAccess; }
  99                 }
 100
 101                 public bool AllRetTypes
 102                 {
 103                         get { return _allRetTypes; }
 104                 }
 105
 106                 public bool AllArguments
 107                 {
 108                         get { return _allArguments; }
 109                 }
 110
 111                 public override bool Equals(object obj)
 112                 {
 113                         MethodSignature otherMethod = obj as MethodSignature;
 114
 115                         if (otherMethod == null)
 116                         {
 117                                 return false;
 118                         }
 119
 120                         if (otherMethod.AllRetTypes == AllRetTypes &&
 121                                 otherMethod.AllArguments == AllArguments &&
 122                                 otherMethod.ArgumentsHashCode() == ArgumentsHashCode() &&
 123                                 otherMethod.MethodName.Equals(MethodName) &&
 124                                 otherMethod.RetType.Equals(RetType) &&
 125                                 otherMethod.Access.Equals(Access))
 126                         {
 127                                 return true;
 128                         }
 129
 130                         return false;
 131                 }
 132
 133                 public override int GetHashCode()
 134                 {
 135                         return ArgumentsHashCode() ^ MethodName.GetHashCode() ^ RetType.GetHashCode() ^ Access.GetHashCode();
 136                 }
 137
 138                 public override String ToString()
 139                 {
 140                         return String.Format("({0} {1} {2}{3})", Access, RetType, MethodName, BuildArguments());
 141                 }
 142
 143                 private int ArgumentsHashCode()
 144                 {
 145                         int argsHash = _arguments.Count + 1;
 146                         foreach(object item in _arguments)
 147                         {
 148                                 argsHash = argsHash ^ item.GetHashCode();
 149                         }
 150                         return argsHash;
 151                 }
 152
 153                 private String BuildArguments()
 154                 {
 155                         if (_allArguments)
 156                         {
 157                                 return "(" + ALL_MARK + ")";
 158                         }
 159                         else if (_arguments.Count == 0)
 160                         {
 161                                 return "()";
 162                         }
 163                         else
 164                         {
 165                                 // I know this is optimized et al.
 166                                 // TODO: Refactor
 167
 168                                 String signature = "("; bool comma = false;
 169
 170                                 foreach(object item in _arguments)
 171                                 {
 172                                         if (comma) signature += ", "; else comma = true;
 173                                         signature += item.ToString();
 174                                 }
 175
 176                                 signature += ")";
 177
 178                                 return signature;
 179                         }
 180                 }
 181         }
 182 }