Tools/Castle.DynamicProxy2/Castle.DynamicProxy.Tests/GenInterfaces/GenInterfaceWithGenericTypes.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 Castle.DynamicProxy.Tests.GenInterfaces
  16 {
  17         using System;
  18         using System.Collections;
  19         using System.Collections.Generic;
  20         using System.Reflection;
  21         using Castle.Core.Interceptor;
  22
  23         public interface GenInterfaceWithGenericTypes
  24         {
  25                 IList Find(string[,] query);
  26
  27                 IList<T> Find<T>(string query);
  28
  29                 IList<String> FindStrings(string query);
  30
  31                 void Populate<T>(IList<T> list);
  32         }
  33
  34         public class GenInterfaceWithGenericTypesImpl : GenInterfaceWithGenericTypes
  35         {
  36                 public IList Find(string[,] query)
  37                 {
  38                         return new String[0];
  39                 }
  40
  41                 public IList Find(string query)
  42                 {
  43                         return new String[0];
  44                 }
  45
  46                 public IList<T> Find<T>(string query)
  47                 {
  48                         return new List<T>();
  49                 }
  50
  51                 public IList<string> FindStrings(string query)
  52                 {
  53                         return new List<String>();
  54                 }
  55
  56                 public void Populate<T>(IList<T> list)
  57                 {
  58                 }
  59         }
  60
  61         public class Proxy : GenInterfaceWithGenericTypes
  62         {
  63                 private readonly IInterceptor[] interceptors;
  64                 private readonly GenInterfaceWithGenericTypesImpl target;
  65
  66                 public Proxy(IInterceptor[] interceptors, GenInterfaceWithGenericTypesImpl target)
  67                 {
  68                         this.interceptors = interceptors;
  69                         this.target = target;
  70                 }
  71
  72                 public void Populate<T>(IList<T> list)
  73                 {
  74                         Find3Invo<T> inv = new Find3Invo<T>(target, interceptors, typeof(Proxy),
  75                                                             null, null, new object[] {list});
  76                         inv.Proceed();
  77                 }
  78
  79                 public IList Find(string[,] query)
  80                 {
  81                         Find1Invo inv = new Find1Invo(target, interceptors, typeof(Proxy),
  82                                                       null, null, new object[] {query});
  83                         inv.Proceed();
  84
  85                         return (IList) inv.ReturnValue;
  86                 }
  87
  88                 public IList Find(string query)
  89                 {
  90                         Find1InvoA inv = new Find1InvoA(target, interceptors, typeof(Proxy),
  91                                                         null, null, new object[] {query});
  92                         inv.Proceed();
  93
  94                         return (IList) inv.ReturnValue;
  95                 }
  96
  97                 public IList<T> Find<T>(string query)
  98                 {
  99                         Find2Invo<T> inv = new Find2Invo<T>(target, interceptors, typeof(Proxy),
 100                                                             null, null, new object[] {query});
 101                         inv.Proceed();
 102
 103                         return (IList<T>) inv.ReturnValue;
 104                 }
 105
 106                 public IList<string> FindStrings(string query)
 107                 {
 108                         throw new NotImplementedException();
 109                 }
 110
 111                 public class Find2Invo<T> : AbstractInvocation
 112                 {
 113                         private readonly GenInterfaceWithGenericTypesImpl target;
 114
 115                         public Find2Invo(GenInterfaceWithGenericTypesImpl target, IInterceptor[] interceptors, Type targetType,
 116                                          MethodInfo targetMethod, MethodInfo interfMethod, object[] arguments)
 117                                 : base(target, target, interceptors, targetType, targetMethod, interfMethod, arguments)
 118                         {
 119                                 this.target = target;
 120                         }
 121
 122                         protected override void InvokeMethodOnTarget()
 123                         {
 124                                 ReturnValue = target.Find<T>((String) GetArgumentValue(0));
 125                         }
 126                 }
 127
 128                 public class Find1Invo : AbstractInvocation
 129                 {
 130                         private readonly GenInterfaceWithGenericTypesImpl target;
 131
 132                         public Find1Invo(GenInterfaceWithGenericTypesImpl target, IInterceptor[] interceptors, Type targetType,
 133                                          MethodInfo targetMethod, MethodInfo interfMethod, object[] arguments) :
 134                                                 base(target, target, interceptors, targetType, targetMethod, interfMethod, arguments)
 135                         {
 136                                 this.target = target;
 137                         }
 138
 139                         protected override void InvokeMethodOnTarget()
 140                         {
 141                                 ReturnValue = target.Find((String[,]) GetArgumentValue(0));
 142                         }
 143                 }
 144
 145                 public class Find1InvoA : AbstractInvocation
 146                 {
 147                         private readonly GenInterfaceWithGenericTypesImpl target;
 148
 149                         public Find1InvoA(GenInterfaceWithGenericTypesImpl target, IInterceptor[] interceptors, Type targetType,
 150                                           MethodInfo targetMethod, MethodInfo interfMethod, object[] arguments)
 151                                 :
 152                                         base(target, target, interceptors, targetType, targetMethod, interfMethod, arguments)
 153                         {
 154                                 this.target = target;
 155                         }
 156
 157                         protected override void InvokeMethodOnTarget()
 158                         {
 159                                 ReturnValue = target.Find((String) GetArgumentValue(0));
 160                         }
 161                 }
 162
 163                 public class Find3Invo<T> : AbstractInvocation
 164                 {
 165                         private readonly GenInterfaceWithGenericTypesImpl target;
 166
 167                         public Find3Invo(GenInterfaceWithGenericTypesImpl target,
 168                                          IInterceptor[] interceptors, Type targetType,
 169                                          MethodInfo targetMethod, MethodInfo interfMethod, object[] arguments)
 170                                 : base(target, target, interceptors, targetType, targetMethod, interfMethod, arguments)
 171                         {
 172                                 this.target = target;
 173                         }
 174
 175                         protected override void InvokeMethodOnTarget()
 176                         {
 177                                 target.Populate((List<T>) GetArgumentValue(0));
 178                         }
 179                 }
 180         }
 181 }