Tools/Castle.DynamicProxy2/Castle.DynamicProxy/Generators/Emitters/PropertyEmitter.cs

   1 // Copyright 2004-2007 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 Castle.DynamicProxy.Generators.Emitters
  16 {
  17         using System;
  18         using System.Reflection;
  19         using System.Reflection.Emit;
  20         using Castle.DynamicProxy.Generators.Emitters.SimpleAST;
  21
  22         public class PropertyEmitter : IMemberEmitter
  23         {
  24                 private PropertyBuilder builder;
  25                 private AbstractTypeEmitter parentTypeEmitter;
  26                 private MethodEmitter getMethod;
  27                 private MethodEmitter setMethod;
  28                 // private ParameterInfo[] indexParameters;
  29
  30                 public PropertyEmitter(AbstractTypeEmitter parentTypeEmitter, String name, PropertyAttributes attributes,
  31                                        Type propertyType)
  32                 {
  33                         this.parentTypeEmitter = parentTypeEmitter;
  34
  35                         builder = parentTypeEmitter.TypeBuilder.DefineProperty(name, attributes, propertyType, new Type[0]);
  36                 }
  37
  38                 public MethodEmitter GetMethod
  39                 {
  40                         get { return getMethod; }
  41                         set { getMethod = value; }
  42                 }
  43
  44                 public MethodEmitter SetMethod
  45                 {
  46                         get { return setMethod; }
  47                         set { setMethod = value; }
  48                 }
  49
  50                 public MethodEmitter CreateGetMethod()
  51                 {
  52                         return CreateGetMethod(MethodAttributes.Public |
  53                                                MethodAttributes.Virtual |
  54                                                MethodAttributes.SpecialName);
  55                 }
  56
  57                 public MethodEmitter CreateGetMethod(MethodAttributes attrs, params Type[] parameters)
  58                 {
  59                         if (getMethod != null)
  60                         {
  61                                 throw new InvalidOperationException("A getMethod exists");
  62                         }
  63
  64                         if (parameters.Length == 0)
  65                         {
  66                                 getMethod = new MethodEmitter(parentTypeEmitter, "get_" + builder.Name, attrs);
  67                         }
  68                         else
  69                         {
  70                                 getMethod = new MethodEmitter(parentTypeEmitter, "get_" + builder.Name,
  71                                                               attrs,
  72                                                               ReturnType,
  73                                                               parameters);
  74                         }
  75
  76                         return getMethod;
  77                 }
  78
  79                 public MethodEmitter CreateSetMethod()
  80                 {
  81                         return CreateSetMethod(MethodAttributes.Public |
  82                                                MethodAttributes.Virtual |
  83                                                MethodAttributes.SpecialName);
  84                 }
  85
  86                 public MethodEmitter CreateSetMethod(Type arg)
  87                 {
  88                         return CreateSetMethod(MethodAttributes.Public |
  89                                                MethodAttributes.Virtual |
  90                                                MethodAttributes.SpecialName, arg);
  91                 }
  92
  93                 public MethodEmitter CreateSetMethod(MethodAttributes attrs, params Type[] parameters)
  94                 {
  95                         if (setMethod != null)
  96                         {
  97                                 throw new InvalidOperationException("A setMethod exists");
  98                         }
  99
 100                         if (parameters.Length == 0)
 101                         {
 102                                 setMethod = new MethodEmitter(parentTypeEmitter, "set_" + builder.Name, attrs);
 103                         }
 104                         else
 105                         {
 106                                 setMethod = new MethodEmitter(parentTypeEmitter, "set_" + builder.Name,
 107                                                               attrs, typeof(void),
 108                                                               parameters);
 109                         }
 110
 111                         return setMethod;
 112                 }
 113
 114                 public MemberInfo Member
 115                 {
 116                         get { return null; }
 117                 }
 118
 119                 public Type ReturnType
 120                 {
 121                         get { return builder.PropertyType; }
 122                 }
 123
 124                 public void Generate()
 125                 {
 126                         if (setMethod != null)
 127                         {
 128                                 setMethod.Generate();
 129                                 builder.SetSetMethod(setMethod.MethodBuilder);
 130                         }
 131
 132                         if (getMethod != null)
 133                         {
 134                                 getMethod.Generate();
 135                                 builder.SetGetMethod(getMethod.MethodBuilder);
 136                         }
 137                 }
 138
 139                 public void EnsureValidCodeBlock()
 140                 {
 141                         if (setMethod != null)
 142                         {
 143                                 setMethod.EnsureValidCodeBlock();
 144                         }
 145
 146                         if (getMethod != null)
 147                         {
 148                                 getMethod.EnsureValidCodeBlock();
 149                         }
 150                 }
 151         }
 152 }