private void ProcessArray(IReflector reflector, Type type, ISpecification holder) {
FacetUtils.AddFacet(new ArrayFacet(holder));
FacetUtils.AddFacet(new TypeOfFacetInferredFromArray(holder));
var elementType = type.GetElementType();
reflector.LoadSpecification(elementType);
}
public override void Process(IReflector reflector, MethodInfo method, IMethodRemover methodRemover, ISpecificationBuilder specification) {
if ((method.ReturnType.IsPrimitive || TypeUtils.IsEnum(method.ReturnType)) && method.GetCustomAttribute<OptionallyAttribute>() != null) {
Log.Warn("Ignoring Optionally annotation on primitive parameter on " + method.ReflectedType + "." + method.Name);
return;
}
Process(method, specification);
}
public override void Process(IReflector reflector, PropertyInfo method, IMethodRemover methodRemover, ISpecificationBuilder specification) {
if (method.PropertyType.IsAssignableFrom(typeof(ContactType))) {
FacetUtils.AddFacet(new NotNavigableFacet(specification));
}
if (method.PropertyType.IsAssignableFrom(typeof(AddressType))) {
FacetUtils.AddFacet(new NotNavigableFacet(specification));
}
if (method.PropertyType.IsAssignableFrom(typeof(ContactType))) {
FacetUtils.AddFacet(new NotNavigableFacet(specification));
}
if (method.PropertyType.IsAssignableFrom(typeof(Culture))) {
FacetUtils.AddFacet(new NotNavigableFacet(specification));
}
if (method.PropertyType.IsAssignableFrom(typeof(SalesReason))) {
FacetUtils.AddFacet(new NotNavigableFacet(specification));
}
if (method.PropertyType.IsAssignableFrom(typeof(UnitMeasure))) {
FacetUtils.AddFacet(new NotNavigableFacet(specification));
}
if (method.PropertyType.IsAssignableFrom(typeof(ScrapReason))) {
FacetUtils.AddFacet(new NotNavigableFacet(specification));
}
if (method.PropertyType.IsAssignableFrom(typeof(ProductSubcategory))) {
FacetUtils.AddFacet(new NotNavigableFacet(specification));
}
if (method.PropertyType.IsAssignableFrom(typeof(ProductCategory))) {
FacetUtils.AddFacet(new NotNavigableFacet(specification));
}
}
public override void ProcessParams(IReflector reflector, MethodInfo method, int paramNum, ISpecificationBuilder holder) {
ParameterInfo parameter = method.GetParameters()[paramNum];
if (TypeUtils.IsString(parameter.ParameterType)) {
var attribute = parameter.GetCustomAttribute<MultiLineAttribute>();
FacetUtils.AddFacet(Create(attribute, holder));
}
}
public override void Process(IReflector reflector, Type type, IMethodRemover methodRemover, ISpecificationBuilder spec) {
var attr = type.GetCustomAttribute<NakedObjectsTypeAttribute>();
if (attr == null) {
RemoveExplicitlyIgnoredMembers(type, methodRemover);
} else {
switch (attr.ReflectionScope) {
case ReflectOver.All:
RemoveExplicitlyIgnoredMembers(type, methodRemover);
break;
case ReflectOver.TypeOnlyNoMembers:
foreach (MethodInfo method in type.GetMethods()) {
methodRemover.RemoveMethod(method);
}
break;
case ReflectOver.ExplicitlyIncludedMembersOnly:
foreach (MethodInfo method in type.GetMethods()) {
if (method.GetCustomAttribute<NakedObjectsIncludeAttribute>() == null) {
methodRemover.RemoveMethod(method);
}
}
break;
case ReflectOver.None:
throw new ReflectionException("Attempting to introspect a class that has been marked with NakedObjectsType with ReflectOver.None");
default:
throw new ReflectionException(String.Format("Unhandled value for ReflectOver: {0}", attr.ReflectionScope));
}
}
}
public virtual IReflectClass ClassReflector(IReflector reflector, ClassMetadata classMetadata
, bool isPrimitive)
{
return isPrimitive
? Handlers4.PrimitiveClassReflector(classMetadata, reflector)
: classMetadata.ClassReflector();
}
private void Process(IReflector reflector, MethodInfo member, ISpecification holder) {
var allParams = member.GetParameters();
var paramsWithAttribute = allParams.Where(p => p.GetCustomAttribute<ContributedActionAttribute>() != null).ToArray();
if (!paramsWithAttribute.Any()) return; //Nothing to do
var facet = new ContributedActionFacet(holder);
foreach (ParameterInfo p in paramsWithAttribute) {
var attribute = p.GetCustomAttribute<ContributedActionAttribute>();
var type = reflector.LoadSpecification<IObjectSpecImmutable>(p.ParameterType);
if (type != null) {
if (type.IsParseable) {
Log.WarnFormat("ContributedAction attribute added to a value parameter type: {0}", member.Name);
}
else if (type.IsCollection) {
var parent = reflector.LoadSpecification(member.DeclaringType);
if (parent is IObjectSpecBuilder) {
AddLocalCollectionContributedAction(reflector, p, facet);
}
else {
AddCollectionContributedAction(reflector, member, type, p, facet, attribute);
}
}
else {
facet.AddObjectContributee(type, attribute.SubMenu, attribute.Id);
}
}
}
FacetUtils.AddFacet(facet);
}
public NetConstructor(IReflector reflector, ConstructorInfo
constructor)
{
this.reflector = reflector;
this.constructor = constructor;
Platform4.SetAccessible(constructor);
}
public override void Process(IReflector reflector, Type type, IMethodRemover methodRemover, ISpecificationBuilder specification) {
IFacet facet = null;
if (!type.IsInterface && typeof (IViewModel).IsAssignableFrom(type)) {
MethodInfo deriveMethod = type.GetMethod("DeriveKeys", new Type[] {});
MethodInfo populateMethod = type.GetMethod("PopulateUsingKeys", new[] {typeof (string[])});
var toRemove = new List<MethodInfo> {deriveMethod, populateMethod};
if (typeof (IViewModelEdit).IsAssignableFrom(type)) {
facet = new ViewModelEditFacetConvention(specification);
}
else if (typeof (IViewModelSwitchable).IsAssignableFrom(type)) {
MethodInfo isEditViewMethod = type.GetMethod("IsEditView");
toRemove.Add(isEditViewMethod);
facet = new ViewModelSwitchableFacetConvention(specification);
}
else {
facet = new ViewModelFacetConvention(specification);
}
methodRemover.RemoveMethods(toRemove.ToArray());
}
FacetUtils.AddFacet(facet);
}
public EnigmaMachine(IAlphabet alphabet, IRotor leftRotor, IRotor centerRotor, IRotor righRotor, IReflector reflector)
{
_alphabet = alphabet;
_leftRotor = leftRotor;
_centerRotor = centerRotor;
_rightRotor = righRotor;
_reflector = reflector;
}
public override void Process(IReflector reflector, Type type, IMethodRemover methodRemover, ISpecificationBuilder specification) {
if (typeof (IEnumerable).IsAssignableFrom(type) && !TypeUtils.IsSystem(type)) {
MethodInfo method = FindMethod(reflector, type, MethodType.Object, RecognisedMethodsAndPrefixes.GetEnumeratorMethod, null, Type.EmptyTypes);
if (method != null) {
methodRemover.RemoveMethod(method);
}
}
}
public virtual IReflectClass ClassReflector(IReflector reflector)
{
if (_classReflector == null)
{
_classReflector = ((IBuiltinTypeHandler)GetHandler()).ClassReflector();
}
return _classReflector;
}
//---------------------------------------------------------------------
// Constructor
//---------------------------------------------------------------------
/**
* Creates a new <code>CommandMap</code> object
*
* @param eventDispatcher The <code>IEventDispatcher</code> to listen to
* @param injector An <code>IInjector</code> to use for this context
* @param reflector An <code>IReflector</code> to use for this context
*/
public CommandMap( IEventDispatcher eventDispatcher, IInjector injector, IReflector reflector )
{
this.eventDispatcher = eventDispatcher;
this.injector = injector;
this.reflector = reflector;
this.eventTypeMap = new Dictionary<string,Dictionary<Type, Dictionary<Type, Action<Event>>>>();
this.verifiedCommandClasses = new Dictionary<Type,bool>();
}
public override void Process(IReflector reflector, PropertyInfo property, IMethodRemover methodRemover, ISpecificationBuilder specification) {
if (CollectionUtils.IsCollectionButNotArray(property.PropertyType)) {
specification.AddFacet(new CollectionResetFacet(property, specification));
}
else {
base.Process(reflector, property, methodRemover, specification);
}
}
public override void Process(IReflector reflector, Type type, IMethodRemover methodRemover, ISpecificationBuilder specification) {
FacetUtils.AddFacets(
new IFacet[] {
new DescribedAsFacetNone(specification),
new ImmutableFacetNever(specification),
new TitleFacetNone(specification)
});
}
public virtual void RegisterReflector(IReflector reflector)
{
_classReflector = reflector.ForClass(JavaClass());
var clazz = PrimitiveJavaClass();
if (clazz != null)
{
_primitiveClassReflector = reflector.ForClass(clazz);
}
}
public override void Process(IReflector reflector, PropertyInfo property, IMethodRemover methodRemover, ISpecificationBuilder specification) {
if ((property.PropertyType.IsPrimitive || TypeUtils.IsEnum(property.PropertyType)) && property.GetCustomAttribute<OptionallyAttribute>() != null) {
Log.Warn("Ignoring Optionally annotation on primitive or un-readable parameter on " + property.ReflectedType + "." + property.Name);
return;
}
if (property.GetGetMethod() != null && !property.PropertyType.IsPrimitive) {
Process(property, specification);
}
}
public override void Process(IReflector reflector, Type type, IMethodRemover methodRemover, ISpecificationBuilder specification) {
if (IsDynamicProxyType(type)) {
foreach (MethodInfo method in type.GetMethods().Join(MethodsToRemove, mi => mi.Name, s => s, (mi, s) => mi)) {
if (methodRemover != null && method != null) {
methodRemover.RemoveMethod(method);
}
}
}
}
public override void ProcessParams(IReflector reflector, MethodInfo method, int paramNum, ISpecificationBuilder holder) {
ParameterInfo parameter = method.GetParameters()[paramNum];
if (IsDatetimeOrNullableDateTime(parameter.ParameterType)) {
var dataTypeAttribute = parameter.GetCustomAttribute<DataTypeAttribute>();
var concurrencyCheckAttribute = parameter.GetCustomAttribute<ConcurrencyCheckAttribute>();
FacetUtils.AddFacet(Create(dataTypeAttribute, concurrencyCheckAttribute, holder));
}
}
public override void Process(IReflector reflector, Type type, IMethodRemover methodRemover, ISpecificationBuilder specification) {
Type currentType = type;
while (currentType != null) {
if (TypeUtils.IsSystem(currentType)) {
ProcessSystemType(currentType, methodRemover, specification);
}
currentType = currentType.BaseType;
}
}
public override void Process(IReflector reflector, Type type, IMethodRemover methodRemover, ISpecificationBuilder specification) {
if (typeof (Enum).IsAssignableFrom(type)) {
Type semanticsProviderType = typeof (EnumValueSemanticsProvider<>).MakeGenericType(type);
var spec = reflector.LoadSpecification<IObjectSpecImmutable>(type);
object semanticsProvider = Activator.CreateInstance(semanticsProviderType, spec, specification);
MethodInfo method = typeof (ValueUsingValueSemanticsProviderFacetFactory).GetMethod("AddValueFacets", BindingFlags.Static | BindingFlags.Public).MakeGenericMethod(type);
method.Invoke(null, new[] {semanticsProvider, specification});
}
}
public SelfClass(IReflector parentReflector, SelfReflectionRegistry registry, Type
clazz)
{
// public SelfClass() {
// super();
// }
_parentReflector = parentReflector;
_registry = registry;
_class = clazz;
}
public void RunBeforeEachTest()
{
eventDispatcher = new EventDispatcher();
injector = new UnityInjector();
reflector = new UnityReflector();
commandMap = new CommandMap( eventDispatcher, injector, reflector );
//TODO Use the Unity lifetimemanager here
injector.MapValue( typeof(ICommandTest), this );
}
public static IReflectClass PrimitiveClassReflector(ITypeHandler4 handler, IReflector
reflector)
{
ITypeHandler4 baseTypeHandler = BaseTypeHandler(handler);
if (baseTypeHandler is PrimitiveHandler)
{
return ((PrimitiveHandler)baseTypeHandler).PrimitiveClassReflector();
}
return null;
}
public override void Process(IReflector reflector, Type type, IMethodRemover methodRemover, ISpecificationBuilder specification) {
var facets = new List<IFacet> {
new TypeIsAbstractFacet(specification, IsAbstract(type)),
new TypeIsInterfaceFacet(specification, IsInterface(type)),
new TypeIsSealedFacet(specification, IsSealed(type)),
new TypeIsVoidFacet(specification, IsVoid(type))
};
FacetUtils.AddFacets(facets);
}
public override void Process(IReflector reflector, Type type, IMethodRemover methodRemover, ISpecificationBuilder specification) {
MethodInfo method = FindMethod(reflector, type, MethodType.Class, RecognisedMethodsAndPrefixes.MenuMethod, null, null);
if (method != null) {
RemoveMethod(methodRemover, method);
FacetUtils.AddFacet(new MenuFacetViaMethod(method, specification));
}
else {
FacetUtils.AddFacet(new MenuFacetDefault(specification));
}
}
public ForEachTagParser(IReflector reflector, IFilterRunner filterRunner)
{
if (reflector == null)
throw new ArgumentNullException("reflector");
this.reflector = reflector;
if (filterRunner == null)
throw new ArgumentNullException("filterRunner");
this.filterRunner = filterRunner;
}
public override IReflectClass ClassReflector(IReflector reflector, ClassMetadata
classMetadata, bool isPrimitive)
{
IReflectClass primitiveClaxx = Handlers4.PrimitiveClassReflector(classMetadata, reflector
);
if (primitiveClaxx != null)
{
return primitiveClaxx;
}
return base.ClassReflector(reflector, classMetadata, isPrimitive);
}
public override void ProcessParams(IReflector reflector, MethodInfo method, int paramNum, ISpecificationBuilder holder) {
ParameterInfo parameter = method.GetParameters()[paramNum];
if (parameter.ParameterType.IsPrimitive || TypeUtils.IsEnum(parameter.ParameterType)) {
if (method.GetCustomAttribute<OptionallyAttribute>() != null) {
Log.Warn("Ignoring Optionally annotation on primitive parameter " + paramNum + " on " + method.ReflectedType + "." + method.Name);
}
return;
}
var attribute = parameter.GetCustomAttribute<OptionallyAttribute>();
FacetUtils.AddFacet(Create(attribute, holder));
}
public RuntimeServer( IReader reader
, IBaseMarshaller marshaller
, IReferenceManager referenceManager
, IReflector reflector
)
{
this.reader = reader;
this.marshaller = marshaller;
this.referenceManager = referenceManager;
this.reflector = reflector;
}
public virtual void SetParent(IReflector reflector)
{
_parent = reflector;
}
public DrsTestSuiteBuilder(IDrsProviderFixture a, IDrsProviderFixture b, Type[] classes
, IReflector reflector) : base(AppendDestructor(classes))
{
_fixtures = new DrsFixture(a, b, reflector);
}
public IImmutableDictionary <string, ITypeSpecBuilder> ProcessParams(IReflector reflector, MethodInfo method, int paramNum, ISpecificationBuilder holder, IImmutableDictionary <string, ITypeSpecBuilder> metamodel) => metamodel;
public override IImmutableDictionary <string, ITypeSpecBuilder> Process(IReflector reflector, MethodInfo method, ISpecificationBuilder specification, IImmutableDictionary <string, ITypeSpecBuilder> metamodel)
{
FacetUtils.AddFacet(Create(specification));
return(metamodel);
}
public ImmutableDictionary <string, ITypeSpecBuilder> ProcessParams(IReflector reflector, MethodInfo method, int paramNum, ISpecificationBuilder specification, ImmutableDictionary <string, ITypeSpecBuilder> metamodel)
{
throw new NotImplementedException();
}
protected SmartInvoker(object instance, IReflectPolicy policy)
{
instance.ThrowIfNullArgument(nameof(instance));
_r = Reflector.Bind(instance, policy);
}
public override IImmutableDictionary <string, ITypeSpecBuilder> ProcessParams(IReflector reflector, MethodInfo method, int paramNum, ISpecificationBuilder holder, IImmutableDictionary <string, ITypeSpecBuilder> metamodel)
{
var facets = new List <IFacet>();
if (holder is IActionParameterSpecImmutable param)
{
var name = method.GetParameters()[paramNum].Name ?? method.GetParameters()[paramNum].ParameterType.FullName;
INamedFacet namedFacet = new NamedFacetInferred(name, holder);
facets.Add(namedFacet);
facets.Add(new DescribedAsFacetNone(holder));
facets.Add(new MultiLineFacetNone(holder));
facets.Add(new MaxLengthFacetZero(holder));
facets.Add(new TypicalLengthFacetZero(holder));
DefaultTypicalLength(facets, param.Specification, param);
}
FacetUtils.AddFacets(facets);
return(metamodel);
}
public override void Process(IReflector reflector, PropertyInfo property, IMethodRemover methodRemover, ISpecificationBuilder specification)
{
FacetUtils.AddFacet(Create(specification));
}
public override IImmutableDictionary <string, ITypeSpecBuilder> ProcessParams(IReflector reflector, MethodInfo method, int paramNum, ISpecificationBuilder holder, IImmutableDictionary <string, ITypeSpecBuilder> metamodel)
{
FacetUtils.AddFacet(Create(holder));
return(metamodel);
}
public override void Process(IReflector reflector, MethodInfo method, IMethodRemover methodRemover, ISpecificationBuilder specification) => FacetUtils.AddFacet(Create(specification));
public override IImmutableDictionary <string, ITypeSpecBuilder> Process(IReflector reflector, Type type, IMethodRemover methodRemover, ISpecificationBuilder specification, IImmutableDictionary <string, ITypeSpecBuilder> metamodel)
{
return(metamodel);
}
public GenericReflector(IReflector delegateReflector) : this(null, delegateReflector
)
{
}
public DiContainer(IReflector reflector)
{
Requires.NotNull(reflector, nameof(reflector));
this.reflector = reflector;
}
public override void Process(IReflector reflector, Type type, IMethodRemover methodRemover, ISpecificationBuilder specification)
{
var attribute = type.GetCustomAttribute <ProgramPersistableOnlyAttribute>();
FacetUtils.AddFacet(Create(attribute, specification));
}
public override IImmutableDictionary <string, ITypeSpecBuilder> Process(IReflector reflector, PropertyInfo property, ISpecificationBuilder specification, IImmutableDictionary <string, ITypeSpecBuilder> metamodel)
{
Process(specification);
return(metamodel);
}
public override void ProcessParams(IReflector reflector, MethodInfo method, int paramNum, ISpecificationBuilder holder)
{
FacetUtils.AddFacet(Create(holder));
}
public virtual void ProcessParams(IReflector reflector, MethodInfo method, int paramNum, ISpecificationBuilder holder)
{
}
public override void Process(IReflector reflector, MethodInfo method, IMethodRemover methodRemover, ISpecificationBuilder specification)
{
Process(specification);
}
public ImmutableDictionary <string, ITypeSpecBuilder> Process(IReflector reflector, PropertyInfo property, IMethodRemover methodRemover, ISpecificationBuilder specification, FeatureType featureType, ImmutableDictionary <string, ITypeSpecBuilder> metamodel)
{
throw new NotImplementedException();
}
public override void Process(IReflector reflector, PropertyInfo property, IMethodRemover methodRemover, ISpecificationBuilder specification)
{
var attribute = property.GetCustomAttribute <NotNavigableAttribute>() ?? property.PropertyType.GetCustomAttribute <NotNavigableAttribute>();
FacetUtils.AddFacet(Create(attribute, specification));
}
public override void Process(IReflector reflector, Type type, IMethodRemover methodRemover, ISpecificationBuilder specification)
{
Attribute attribute = type.GetCustomAttribute <RegularExpressionAttribute>() ?? (Attribute)type.GetCustomAttribute <RegExAttribute>();
FacetUtils.AddFacet(Create(attribute, specification));
}
public virtual void Process(IReflector reflector, PropertyInfo property, IMethodRemover methodRemover, ISpecificationBuilder specification)
{
}
public override void Process(IReflector reflector, PropertyInfo property, IMethodRemover methodRemover, ISpecificationBuilder specification)
{
Process(specification);
}
public IImmutableDictionary <string, ITypeSpecBuilder> Process(IReflector reflector, PropertyInfo property, IMethodRemover methodRemover, ISpecificationBuilder specification, IImmutableDictionary <string, ITypeSpecBuilder> metamodel) => metamodel;
public ReflectorToInstanceSerializerAdapater(IReflector reflector, Constructor constructor)
{
this.reflector = reflector;
this.constructor = constructor;
}
public override IImmutableDictionary <string, ITypeSpecBuilder> ProcessParams(IReflector reflector, MethodInfo method, int paramNum, ISpecificationBuilder holder, IImmutableDictionary <string, ITypeSpecBuilder> metamodel)
{
ParameterInfo parameter = method.GetParameters()[paramNum];
var dataTypeAttribute = parameter.GetCustomAttribute <DataTypeAttribute>();
FacetUtils.AddFacet(Create(dataTypeAttribute, holder));
return(metamodel);
}
public DrsTestSuiteBuilder(IDrsProviderFixture a, IDrsProviderFixture b, Type clazz
, IReflector reflector) : this(a, b, new Type[] { clazz }, reflector)
{
}
public virtual void Process(IReflector reflector, MethodInfo method, IMethodRemover methodRemover, ISpecificationBuilder specification)
{
}
/// <param name="reflector"></param>
internal SelfArray(IReflector reflector, SelfReflectionRegistry registry)
{
_registry = registry;
}
public override void Process(IReflector reflector, Type type, IMethodRemover remover, ISpecificationBuilder specification)
{
var facets = new List <IFacet>();
var methods = new List <MethodInfo>();
var method = FindMethod(reflector, type, MethodType.Object, RecognisedMethodsAndPrefixes.CreatedMethod, typeof(void), Type.EmptyTypes);
if (method != null)
{
methods.Add(method);
facets.Add(new CreatedCallbackFacetViaMethod(method, specification));
}
else
{
facets.Add(new CreatedCallbackFacetNull(specification));
}
method = FindMethod(reflector, type, MethodType.Object, RecognisedMethodsAndPrefixes.PersistingMethod, typeof(void), Type.EmptyTypes);
if (method != null)
{
methods.Add(method);
facets.Add(new PersistingCallbackFacetViaMethod(method, specification));
}
else
{
facets.Add(new PersistingCallbackFacetNull(specification));
}
method = FindMethod(reflector, type, MethodType.Object, RecognisedMethodsAndPrefixes.PersistedMethod, typeof(void), Type.EmptyTypes);
if (method != null)
{
methods.Add(method);
facets.Add(new PersistedCallbackFacetViaMethod(method, specification));
}
else
{
facets.Add(new PersistedCallbackFacetNull(specification));
}
method = FindMethod(reflector, type, MethodType.Object, RecognisedMethodsAndPrefixes.UpdatingMethod, typeof(void), Type.EmptyTypes);
if (method != null)
{
methods.Add(method);
facets.Add(new UpdatingCallbackFacetViaMethod(method, specification));
}
else
{
facets.Add(new UpdatingCallbackFacetNull(specification));
}
method = FindMethod(reflector, type, MethodType.Object, RecognisedMethodsAndPrefixes.UpdatedMethod, typeof(void), Type.EmptyTypes);
if (method != null)
{
methods.Add(method);
facets.Add(new UpdatedCallbackFacetViaMethod(method, specification));
}
else
{
facets.Add(new UpdatedCallbackFacetNull(specification));
}
method = FindMethod(reflector, type, MethodType.Object, RecognisedMethodsAndPrefixes.LoadingMethod, typeof(void), Type.EmptyTypes);
if (method != null)
{
methods.Add(method);
facets.Add(new LoadingCallbackFacetViaMethod(method, specification));
}
else
{
facets.Add(new LoadingCallbackFacetNull(specification));
}
method = FindMethod(reflector, type, MethodType.Object, RecognisedMethodsAndPrefixes.LoadedMethod, typeof(void), Type.EmptyTypes);
if (method != null)
{
methods.Add(method);
facets.Add(new LoadedCallbackFacetViaMethod(method, specification));
}
else
{
facets.Add(new LoadedCallbackFacetNull(specification));
}
method = FindMethod(reflector, type, MethodType.Object, RecognisedMethodsAndPrefixes.DeletingMethod, typeof(void), Type.EmptyTypes);
if (method != null)
{
methods.Add(method);
facets.Add(new DeletingCallbackFacetViaMethod(method, specification));
}
else
{
facets.Add(new DeletingCallbackFacetNull(specification));
}
method = FindMethod(reflector, type, MethodType.Object, RecognisedMethodsAndPrefixes.DeletedMethod, typeof(void), Type.EmptyTypes);
if (method != null)
{
methods.Add(method);
facets.Add(new DeletedCallbackFacetViaMethod(method, specification));
}
else
{
facets.Add(new DeletedCallbackFacetNull(specification));
}
method = FindMethod(reflector, type, MethodType.Object, RecognisedMethodsAndPrefixes.OnUpdatingErrorMethod, typeof(string), new[] { typeof(Exception) });
if (method != null)
{
methods.Add(method);
facets.Add(new OnUpdatingErrorCallbackFacetViaMethod(method, specification, Logger <OnUpdatingErrorCallbackFacetViaMethod>()));
}
else
{
facets.Add(new OnUpdatingErrorCallbackFacetNull(specification));
}
method = FindMethod(reflector, type, MethodType.Object, RecognisedMethodsAndPrefixes.OnPersistingErrorMethod, typeof(string), new[] { typeof(Exception) });
if (method != null)
{
methods.Add(method);
facets.Add(new OnPersistingErrorCallbackFacetViaMethod(method, specification, Logger <OnPersistingErrorCallbackFacetViaMethod>()));
}
else
{
facets.Add(new OnPersistingErrorCallbackFacetNull(specification));
}
remover.RemoveMethods(methods);
FacetUtils.AddFacets(facets);
}
