AspectSharp/AspectSharp.Lang/AST/Visitors/DepthFirstVisitor.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.Visitors
  16 {
  17         using System;
  18
  19         /// <summary>
  20         /// Summary description for AbstractDepthFirstVisitor.
  21         /// </summary>
  22         public class DepthFirstVisitor : IVisitor
  23         {
  24                 public void Visit(INode node)
  25                 {
  26                         node.Accept(this);
  27                 }
  28
  29                 public void Visit(INode[] nodes)
  30                 {
  31                         foreach(INode node in nodes)
  32                         {
  33                                 Visit(node);
  34                         }
  35                 }
  36
  37                 #region Depth Control Members
  38
  39                 protected virtual bool EnterEngineConfiguration(EngineConfiguration conf)
  40                 {
  41                         return true;
  42                 }
  43
  44                 protected virtual void LeaveEngineConfiguration(EngineConfiguration conf)
  45                 {
  46                 }
  47
  48                 protected virtual bool EnterAspectDefinition(AspectDefinition aspect)
  49                 {
  50                         return true;
  51                 }
  52
  53                 protected virtual void LeaveAspectDefinition(AspectDefinition aspect)
  54                 {
  55                 }
  56
  57                 #endregion
  58
  59                 #region IVisitor Members
  60
  61                 public virtual void OnEngineConfiguration(EngineConfiguration conf)
  62                 {
  63                         if (EnterEngineConfiguration(conf))
  64                         {
  65                                 conf.Imports.Accept(this);
  66                                 conf.Mixins.Accept(this);
  67                                 conf.Interceptors.Accept(this);
  68                                 conf.Aspects.Accept(this);
  69
  70                                 LeaveEngineConfiguration(conf);
  71                         }
  72                 }
  73
  74                 public virtual void OnImportDirective(ImportDirective import)
  75                 {
  76                         if (import.AssemblyReference != null)
  77                         {
  78                                 OnAssemblyReference(import.AssemblyReference);
  79                         }
  80                 }
  81
  82                 public virtual void OnGlobalInterceptorDeclaration(NodeCollectionBase dict)
  83                 {
  84                         Visit(dict.ToNodeArray());
  85                 }
  86
  87                 public virtual void OnGlobalMixinDeclaration(NodeCollectionBase dict)
  88                 {
  89                         Visit(dict.ToNodeArray());
  90                 }
  91
  92
  93                 public virtual void OnExcludedTypes(TypeReferenceCollection types)
  94                 {
  95                         if (types.Count != 0)
  96                         {
  97                                 Visit(types.ToNodeArray());
  98                         }
  99                 }
 100
 101                 public virtual void OnAspectDefinition(AspectDefinition aspect)
 102                 {
 103                         if (EnterAspectDefinition(aspect))
 104                         {
 105                                 OnTargetTypeDefinition(aspect.TargetType);
 106                                 aspect.Mixins.Accept(this);
 107                                 aspect.PointCuts.Accept(this);
 108
 109                                 LeaveAspectDefinition(aspect);
 110                         }
 111                 }
 112
 113                 public virtual void OnTargetNamespace(String nameSpace)
 114                 {
 115                 }
 116
 117                 public virtual void OnTargetTypeDefinition(TargetTypeDefinition targetType)
 118                 {
 119                         if (targetType.TargetStrategy == TargetStrategyEnum.SingleType)
 120                         {
 121                                 OnTypeReferenceDefinition( targetType.SingleType );
 122                         }
 123                         else if (targetType.TargetStrategy == TargetStrategyEnum.Assignable)
 124                         {
 125                                 OnTypeReferenceDefinition( targetType.AssignType );
 126                         }
 127                         else if (targetType.TargetStrategy == TargetStrategyEnum.Namespace)
 128                         {
 129                                 OnTargetNamespace( targetType.NamespaceRoot );
 130                                 OnExcludedTypes( targetType.Excludes );
 131                         }
 132                         else if (targetType.TargetStrategy == TargetStrategyEnum.Custom)
 133                         {
 134                                 OnTypeReferenceDefinition( targetType.CustomMatcherType );
 135                         }
 136                 }
 137
 138                 public virtual void OnPointCutDefinition(PointCutDefinition pointcut)
 139                 {
 140                         pointcut.Advices.Accept(this);
 141                 }
 142
 143                 public virtual void OnTypeReferenceDefinition(TypeReference type)
 144                 {
 145                         if (type.AssemblyReference != null)
 146                         {
 147                                 OnAssemblyReference(type.AssemblyReference);
 148                         }
 149                 }
 150
 151                 public virtual void OnMixinDefinition(MixinDefinition mixin)
 152                 {
 153                         OnTypeReferenceDefinition(mixin.TypeReference);
 154                 }
 155
 156                 public virtual void OnInterceptorDefinition(InterceptorDefinition interceptor)
 157                 {
 158                         OnTypeReferenceDefinition(interceptor.TypeReference);
 159                 }
 160
 161                 public virtual void OnMixinEntryDefinition(MixinEntryDefinition mixin)
 162                 {
 163                         OnTypeReferenceDefinition(mixin.TypeReference);
 164                 }
 165
 166                 public virtual void OnInterceptorEntryDefinition(InterceptorEntryDefinition interceptor)
 167                 {
 168                         OnTypeReferenceDefinition(interceptor.TypeReference);
 169                 }
 170
 171                 public virtual void OnAssemblyReference(AssemblyReference assemblyReference)
 172                 {
 173
 174                 }
 175
 176                 #endregion
 177         }
 178 }