?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Fixing an issue with output parameters that are of type IntPtr
[castle.git] / ActiveRecord / Castle.ActiveRecord / Framework / Internal / ActiveRecordModelBuilder.cs
blobd7132ab695f47bc1cb7e01ddc3282251d77dc3fb
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.ActiveRecord.Framework.Internal
16 {
17 using System;
18 using System.Collections.Generic;
19 using System.Reflection;
20 using Castle.Components.Validator;
21
22 /// <summary>
23 /// Bulids an <see cref="ActiveRecordModel"/> from a type and does some inital validation.
24 /// </summary>
25 public class ActiveRecordModelBuilder
26 {
27 private static readonly BindingFlags DefaultBindingFlags = BindingFlags.DeclaredOnly | BindingFlags.Public |
28 BindingFlags.Instance | BindingFlags.NonPublic;
29
30 private static readonly BindingFlags FieldDefaultBindingFlags = BindingFlags.DeclaredOnly | BindingFlags.Public |
31 BindingFlags.NonPublic | BindingFlags.Instance;
32
33 private static readonly IValidatorRegistry validatorRegistry = new CachedValidationRegistry();
34
35 private readonly ActiveRecordModelCollection coll = new ActiveRecordModelCollection();
36
37 private IModelBuilderExtension extension;
38
39 /// <summary>
40 /// Creates a <see cref="ActiveRecordModel"/> from the specified type.
41 /// </summary>
42 /// <param name="type">The type.</param>
43 /// <returns></returns>
44 public ActiveRecordModel Create(Type type)
45 {
46 if (type == null) throw new ArgumentNullException("type");
47
48 if (type.IsDefined(typeof(ActiveRecordSkipAttribute), false)) return null;
49
50 ActiveRecordModel model = new ActiveRecordModel(type);
51
52 coll.Add(model);
53
54 PopulateModel(model, type);
55
56 ActiveRecordBase.Register(type, model);
57
58 return model;
59 }
60
61 /// <summary>
62 /// Sets the extension.
63 /// </summary>
64 /// <param name="extension">The extension.</param>
65 public void SetExtension(IModelBuilderExtension extension)
66 {
67 this.extension = extension;
68 }
69
70 /// <summary>
71 /// Gets the models.
72 /// </summary>
73 /// <value>The models.</value>
74 public ActiveRecordModelCollection Models
75 {
76 get { return coll; }
77 }
78
79 /// <summary>
80 /// Gets the validator registry used to create the validators
81 /// </summary>
82 public static IValidatorRegistry ValidatorRegistry
83 {
84 get { return validatorRegistry; }
85 }
86
87 /// <summary>
88 /// Populates the model from tye type
89 /// </summary>
90 /// <param name="model">The model.</param>
91 /// <param name="type">The type.</param>
92 private void PopulateModel(ActiveRecordModel model, Type type)
93 {
94 if (extension != null)
95 {
96 extension.ProcessClass(type, model);
97 }
98
99 ProcessActiveRecordAttribute(type, model);
100
101 ProcessImports(type, model);
102
103 ProcessJoinedBaseAttribute(type, model);
104
105 ProcessProperties(type, model);
106
107 ProcessFields(type, model);
108 }
109
110 private static void ProcessImports(Type type, ActiveRecordModel model)
111 {
112 object[] attrs = type.GetCustomAttributes(typeof(ImportAttribute), false);
113
114 foreach (ImportAttribute att in attrs)
115 {
116 ImportModel im = new ImportModel(att);
117 model.Imports.Add(im);
118 }
119 }
120
121 private static void ProcessJoinedBaseAttribute(Type type, ActiveRecordModel model)
122 {
123 model.IsJoinedSubClassBase = type.IsDefined(typeof(JoinedBaseAttribute), false);
124 }
125
126 private static void PopulateActiveRecordAttribute(ActiveRecordAttribute attribute, ActiveRecordModel model)
127 {
128 model.ActiveRecordAtt = attribute;
129
130 if (attribute.DiscriminatorColumn != null)
131 {
132 model.IsDiscriminatorBase = true;
133
134 if (attribute.DiscriminatorValue == null)
135 {
136 throw new ActiveRecordException(
137 String.Format("You must specify a discriminator value for the type {0}", model.Type.FullName));
138 }
139 }
140 else if (attribute.DiscriminatorType != null)
141 {
142 throw new ActiveRecordException(
143 String.Format("The usage of DiscriminatorType for {0} is meaningless", model.Type.FullName));
144 }
145
146 if (model.ActiveRecordAtt.Table == null)
147 {
148 string safename = GetSafeName(model.Type.Name);
149 model.ActiveRecordAtt.Table = ActiveRecordModel.pluralizeTableNames
150 ? Inflector.Pluralize(safename)
151 : safename;
152 }
153 }
154
155 /// <summary>
156 /// Remove the generic part from the type name.
157 /// </summary>
158 /// <param name="name"></param>
159 /// <returns></returns>
160 private static string GetSafeName(string name)
161 {
162 int index = name.IndexOf("`");
163
164 if (index == -1) return name;
165
166 return name.Substring(0, index);
167 }
168
169 private void ProcessFields(Type type, ActiveRecordModel model)
170 {
171 //Check persistent fields of the base class as well
172 if (ShouldCheckBase(type))
173 {
174 ProcessFields(type.BaseType, model);
175 }
176
177 FieldInfo[] fields = type.GetFields(FieldDefaultBindingFlags);
178
179 foreach (FieldInfo field in fields)
180 {
181 if (field.IsDefined(typeof(FieldAttribute), false))
182 {
183 FieldAttribute fieldAtt = field.GetCustomAttributes(typeof(FieldAttribute), false)[0] as FieldAttribute;
184
185 model.Fields.Add(new FieldModel(field, fieldAtt));
186 }
187
188 if (extension != null)
189 {
190 extension.ProcessField(field, model);
191 }
192 }
193 }
194
195 private void ProcessProperties(Type type, ActiveRecordModel model)
196 {
197 // Check persistent properties of the base class as well
198 if (ShouldCheckBase(type))
199 {
200 ProcessProperties(type.BaseType, model);
201 }
202
203 PropertyInfo[] props = type.GetProperties(DefaultBindingFlags);
204
205 foreach(PropertyInfo prop in props)
206 {
207 bool isArProperty = false;
208 AnyModel anyModel;
209 HasManyToAnyModel hasManyToAnyModel;
210
211 if (extension != null)
212 {
213 extension.ProcessProperty(prop, model);
214 }
215
216 object[] valAtts = prop.GetCustomAttributes(typeof(AbstractValidationAttribute), true);
217
218 foreach(AbstractValidationAttribute valAtt in valAtts)
219 {
220 IValidator validator = valAtt.Build();
221 validator.Initialize(validatorRegistry, prop);
222
223 model.Validators.Add(validator);
224 }
225
226 foreach(object attribute in prop.GetCustomAttributes(false))
227 {
228 if (attribute is PrimaryKeyAttribute)
229 {
230 PrimaryKeyAttribute propAtt = attribute as PrimaryKeyAttribute;
231 isArProperty = true;
232
233 // Joined Subclasses must not have PrimaryKey
234 if (type.IsDefined(typeof(JoinedBaseAttribute), true) && // JoinedBase in a superclass
235 !type.IsDefined(typeof(JoinedBaseAttribute), false)) // but not here
236 {
237 throw new ActiveRecordException("You can't specify a PrimaryKeyAttribute in a joined subclass. " +
238 "Check type " + model.Type.FullName);
239 }
240
241 if (prop.PropertyType.IsDefined(typeof(CompositeKeyAttribute), true))
242 {
243 object[] att = prop.PropertyType.GetCustomAttributes(typeof(CompositeKeyAttribute), true);
244
245 CompositeKeyAttribute cAtt = att[0] as CompositeKeyAttribute;
246
247 model.CompositeKey = new CompositeKeyModel(prop, cAtt);
248 }
249 else
250 {
251 if (!propAtt.IsOverride && model.PrimaryKey != null)
252 {
253 throw new ActiveRecordException("You can't specify more than one PrimaryKeyAttribute in a " +
254 "class. Check type " + model.Type.FullName);
255 }
256
257 model.PrimaryKey = new PrimaryKeyModel(prop, propAtt);
258 }
259 }
260 else if (attribute is CompositeKeyAttribute)
261 {
262 CompositeKeyAttribute propAtt = attribute as CompositeKeyAttribute;
263 isArProperty = true;
264
265 model.CompositeKey = new CompositeKeyModel(prop, propAtt);
266 }
267 else if (attribute is AnyAttribute)
268 {
269 AnyAttribute anyAtt = attribute as AnyAttribute;
270 isArProperty = true;
271 anyModel = new AnyModel(prop, anyAtt);
272 model.Anys.Add(anyModel);
273
274 CollectMetaValues(anyModel.MetaValues, prop);
275 }
276 else if (attribute is PropertyAttribute)
277 {
278 PropertyAttribute propAtt = attribute as PropertyAttribute;
279 isArProperty = true;
280
281 // If this property overrides a base class property remove the old one
282 if (propAtt.IsOverride)
283 {
284 for (int index = 0; index < model.Properties.Count; ++index)
285 {
286 PropertyModel oldModel = (PropertyModel)model.Properties[index];
287
288 if (oldModel.Property.Name == prop.Name)
289 {
290 model.Properties.RemoveAt(index);
291 break;
292 }
293 }
294 }
295
296 PropertyModel propModel = new PropertyModel(prop, propAtt);
297 model.Properties.Add(propModel);
298 model.PropertyDictionary[prop.Name] = propModel;
299 }
300 else if (attribute is NestedAttribute)
301 {
302 NestedAttribute propAtt = attribute as NestedAttribute;
303 isArProperty = true;
304
305 ActiveRecordModel nestedModel = new ActiveRecordModel(prop.PropertyType);
306
307 nestedModel.IsNestedType = true;
308
309 Type nestedType = propAtt.MapType ?? prop.PropertyType;
310 nestedModel.IsNestedCompositeType = model.IsNestedCompositeType;
311 ProcessProperties(nestedType, nestedModel);
312 ProcessFields(nestedType, nestedModel);
313
314 NestedModel nested = new NestedModel(prop, propAtt, nestedModel);
315 nestedModel.ParentNested = nested;
316
317 model.Components.Add(nested);
318 }
319 else if (attribute is NestedParentReferenceAttribute)
320 {
321 NestedParentReferenceAttribute nestedParentAtt = attribute as NestedParentReferenceAttribute;
322 isArProperty = true;
323
324 model.ComponentParent.Add(new NestedParentReferenceModel(prop, nestedParentAtt));
325 }
326 else if (attribute is JoinedKeyAttribute)
327 {
328 JoinedKeyAttribute propAtt = attribute as JoinedKeyAttribute;
329 isArProperty = true;
330
331 if (model.Key != null)
332 {
333 throw new ActiveRecordException("You can't specify more than one JoinedKeyAttribute. " +
334 "Check type " + model.Type.FullName);
335 }
336
337 model.Key = new KeyModel(prop, propAtt);
338 }
339 else if (attribute is VersionAttribute)
340 {
341 VersionAttribute propAtt = attribute as VersionAttribute;
342 isArProperty = true;
343
344 if (model.Version != null)
345 {
346 throw new ActiveRecordException("You can't specify more than one VersionAttribute. " +
347 "Check type " + model.Type.FullName);
348 }
349
350 model.Version = new VersionModel(prop, propAtt);
351 }
352 else if (attribute is TimestampAttribute)
353 {
354 TimestampAttribute propAtt = attribute as TimestampAttribute;
355 isArProperty = true;
356
357 if (model.Timestamp != null)
358 {
359 throw new ActiveRecordException("You can't specify more than one TimestampAttribute. " +
360 "Check type " + model.Type.FullName);
361 }
362
363 model.Timestamp = new TimestampModel(prop, propAtt);
364 }
365 // Relations
366 else if (attribute is OneToOneAttribute)
367 {
368 OneToOneAttribute propAtt = attribute as OneToOneAttribute;
369 isArProperty = true;
370
371 model.OneToOnes.Add(new OneToOneModel(prop, propAtt));
372 }
373 else if (attribute is BelongsToAttribute)
374 {
375 BelongsToAttribute propAtt = attribute as BelongsToAttribute;
376 isArProperty = true;
377
378 BelongsToModel btModel = new BelongsToModel(prop, propAtt);
379 model.BelongsTo.Add(btModel);
380 model.BelongsToDictionary[prop.Name] = btModel;
381
382 if (extension != null)
383 {
384 extension.ProcessBelongsTo(prop, btModel, model);
385 }
386 }
387 // The ordering is important here, HasManyToAny must comes before HasMany!
388 else if (attribute is HasManyToAnyAttribute)
389 {
390 HasManyToAnyAttribute propAtt = attribute as HasManyToAnyAttribute;
391 isArProperty = true;
392
393 hasManyToAnyModel = new HasManyToAnyModel(prop, propAtt);
394 model.HasManyToAny.Add(hasManyToAnyModel);
395 model.HasManyToAnyDictionary[prop.Name] = hasManyToAnyModel;
396
397 CollectMetaValues(hasManyToAnyModel.MetaValues, prop);
398
399 if (extension != null)
400 {
401 extension.ProcessHasManyToAny(prop, hasManyToAnyModel, model);
402 }
403 }
404 else if (attribute is HasManyAttribute)
405 {
406 HasManyAttribute propAtt = attribute as HasManyAttribute;
407 isArProperty = true;
408
409 HasManyModel hasManyModel = new HasManyModel(prop, propAtt);
410 if (propAtt.DependentObjects)
411 {
412 ActiveRecordModel dependentObjectModel = new ActiveRecordModel(propAtt.MapType);
413 dependentObjectModel.IsNestedType = true;
414 dependentObjectModel.IsNestedCompositeType = true;
415 ProcessProperties(propAtt.MapType, dependentObjectModel);
416
417 hasManyModel.DependentObjectModel = new DependentObjectModel(prop, propAtt, dependentObjectModel);
418 }
419 model.HasMany.Add(hasManyModel);
420 model.HasManyDictionary[prop.Name] = hasManyModel;
421
422 if (extension != null)
423 {
424 extension.ProcessHasMany(prop, hasManyModel, model);
425 }
426 }
427 else if (attribute is HasAndBelongsToManyAttribute)
428 {
429 HasAndBelongsToManyAttribute propAtt = attribute as HasAndBelongsToManyAttribute;
430 isArProperty = true;
431
432 HasAndBelongsToManyModel habtManyModel = new HasAndBelongsToManyModel(prop, propAtt);
433 model.HasAndBelongsToMany.Add(habtManyModel);
434 model.HasAndBelongsToManyDictionary[prop.Name] = habtManyModel;
435
436 if (extension != null)
437 {
438 extension.ProcessHasAndBelongsToMany(prop, habtManyModel, model);
439 }
440 }
441 else if (attribute is Any.MetaValueAttribute)
442 {
443 if (prop.GetCustomAttributes(typeof(HasManyToAnyAttribute), false).Length == 0 &&
444 prop.GetCustomAttributes(typeof(AnyAttribute), false).Length == 0
445 )
446 throw new ActiveRecordException(
447 "You can't specify an Any.MetaValue without specifying the Any or HasManyToAny attribute. " +
448 "Check type " + prop.DeclaringType.FullName);
449 }
450 else if (attribute is CompositeUserTypeAttribute)
451 {
452 CompositeUserTypeAttribute propAtt = attribute as CompositeUserTypeAttribute;
453 isArProperty = true;
454
455 model.CompositeUserType.Add(new CompositeUserTypeModel(prop, propAtt));
456 }
457
458 if (attribute is CollectionIDAttribute)
459 {
460 CollectionIDAttribute propAtt = attribute as CollectionIDAttribute;
461
462 model.CollectionIDs.Add(new CollectionIDModel(prop, propAtt));
463 }
464 if (attribute is HiloAttribute)
465 {
466 HiloAttribute propAtt = attribute as HiloAttribute;
467
468 model.Hilos.Add(new HiloModel(prop, propAtt));
469 }
470 }
471
472 if (!isArProperty)
473 {
474 model.NotMappedProperties.Add(prop);
475 }
476 }
477 }
478
479 private static void CollectMetaValues(IList<Any.MetaValueAttribute> metaStore, PropertyInfo prop)
480 {
481 if (metaStore == null)
482 throw new ArgumentNullException("metaStore");
483
484 Any.MetaValueAttribute[] metaValues =
485 prop.GetCustomAttributes(typeof(Any.MetaValueAttribute), false) as Any.MetaValueAttribute[];
486
487 if (metaValues == null || metaValues.Length == 0)
488 return;
489
490 foreach (Any.MetaValueAttribute attribute in metaValues)
491 {
492 metaStore.Add(attribute);
493 }
494 }
495
496 private static bool ShouldCheckBase(Type type)
497 {
498 // Changed as suggested http://support.castleproject.org/jira/browse/AR-40
499 bool shouldCheck = IsRootType(type);
500
501 if (shouldCheck) // Perform more checks
502 {
503 Type basetype = type.BaseType;
504
505 while (basetype != typeof(object))
506 {
507 if (basetype.IsDefined(typeof(JoinedBaseAttribute), false)) return false;
508
509 object[] attrs = basetype.GetCustomAttributes(typeof(ActiveRecordAttribute), false);
510
511 if (attrs.Length != 0)
512 {
513 ActiveRecordAttribute arAttribute = attrs[0] as ActiveRecordAttribute;
514 if (arAttribute.DiscriminatorColumn != null)
515 return false;
516 }
517 else
518 {
519 return true;
520 }
521
522 basetype = basetype.BaseType;
523 }
524 }
525
526 return shouldCheck;
527 }
528
529 private static bool IsRootType(Type type)
530 {
531 bool isRootType = type.BaseType != typeof(object) &&
532 type.BaseType != typeof(ActiveRecordBase) &&
533 type.BaseType != typeof(ActiveRecordValidationBase);
534 // && !type.BaseType.IsDefined(typeof(ActiveRecordAttribute), false);
535
536 // generic check
537 if (type.BaseType.IsGenericType)
538 {
539 isRootType = type.BaseType.GetGenericTypeDefinition() != typeof(ActiveRecordBase<>) &&
540 type.BaseType.GetGenericTypeDefinition() != typeof(ActiveRecordValidationBase<>);
541 }
542
543 return isRootType;
544 }
545
546 private static void ProcessActiveRecordAttribute(Type type, ActiveRecordModel model)
547 {
548 object[] attrs = type.GetCustomAttributes(typeof(ActiveRecordAttribute), false);
549
550 if (attrs.Length == 0)
551 {
552 throw new ActiveRecordException(
553 String.Format("Type {0} is not using the ActiveRecordAttribute, which is obligatory.", type.FullName));
554 }
555
556 ActiveRecordAttribute arAttribute = attrs[0] as ActiveRecordAttribute;
557
558 PopulateActiveRecordAttribute(arAttribute, model);
559 }
560 }
561 }
Git import of castle svn