public virtual void DecorateAllHoldersFacets(IFacetHolder holder) {
     if (!IsEmpty) {
         foreach (Type facetType in holder.FacetTypes) {
             DecoratedFacet(facetType, holder);
         }
     }
 }

 public static InteractionBuffer IsValid(IFacetHolder facetHolder, InteractionContext ic, InteractionBuffer buf) {
     IFacet[] facets = facetHolder.GetFacets(FacetFilters.IsA(typeof (IValidatingInteractionAdvisor)));
     foreach (IValidatingInteractionAdvisor advisor in facets) {
         buf.Append(advisor.Invalidates(ic));
     }
     return buf;
 }

        public override bool Process(Type type, IMethodRemover methodRemover, IFacetHolder holder) {
            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(holder);
                }
                else if (typeof (IViewModelSwitchable).IsAssignableFrom(type)) {
                    MethodInfo isEditViewMethod = type.GetMethod("IsEditView");
                    toRemove.Add(isEditViewMethod);
                    facet = new ViewModelSwitchableFacetConvention(holder);
                }
                else {
                    facet = new ViewModelFacetConvention(holder);
                }
                methodRemover.RemoveMethods(toRemove.ToArray());
            }

            return FacetUtils.AddFacet(facet);
        }

 private static bool Process(MemberInfo member, IFacetHolder holder) {
     Attribute attribute = member.GetCustomAttribute<DescriptionAttribute>();
     if (attribute == null) {
         attribute = member.GetCustomAttribute<DescribedAsAttribute>();
     }
     return FacetUtils.AddFacet(Create(attribute, holder));
 }

 protected RegExFacetAbstract(string validation, string format, bool caseSensitive, string failureMessage, IFacetHolder holder)
     : base(Type, holder) {
     validationPattern = validation;
     formatPattern = format;
     isCaseSensitive = caseSensitive;
     this.failureMessage = failureMessage;
 }

 private static InteractionBuffer IsUsable(IFacetHolder facetHolder, InteractionContext ic, InteractionBuffer buf) {
     IFacet[] facets = facetHolder.GetFacets(FacetFilters.IsA(typeof (IDisablingInteractionAdvisor)));
     foreach (IDisablingInteractionAdvisor advisor in facets) {
         buf.Append(advisor.Disables(ic));
     }
     return buf;
 }

 public ActionInvocationFacetViaMethod(MethodInfo method, INakedObjectSpecification onType, INakedObjectSpecification returnType, IFacetHolder holder)
     : base(holder) {
     actionMethod = method;
     paramCount = method.GetParameters().Length;
     this.onType = onType;
     this.returnType = returnType;
 }

 public override bool Process(PropertyInfo property, IMethodRemover methodRemover, IFacetHolder holder) {
     if (CollectionUtils.IsCollectionButNotArray(property.PropertyType)) {
         holder.AddFacet(new CollectionResetFacet(property, holder));
         return true;
     }
     return base.Process(property, methodRemover, holder);
 }

 protected NakedObjectAssociationAbstract(string fieldId, INakedObjectSpecification specification, IFacetHolder facetHolder)
     : base(fieldId, facetHolder) {
     if (specification == null) {
         throw new ArgumentException(string.Format(Resources.NakedObjects.MissingFieldType, fieldId));
     }
     this.specification = specification;
 }

        public PropertyChoicesFacetViaMethod(MethodInfo optionsMethod, IFacetHolder holder)
            : base(holder) {
            method = optionsMethod;

            parameterNamesAndTypes = optionsMethod.GetParameters().Select(p => new Tuple<string, INakedObjectSpecification>(p.Name.ToLower(), NakedObjectsContext.Reflector.LoadSpecification(p.ParameterType))).ToArray();
            parameterNames = parameterNamesAndTypes.Select(pnt => pnt.Item1).ToArray();
        }

 public DescribedAsFacetDynamicWrapI18n(II18nManager manager, IFacetHolder holder, IIdentifier identifier, IDescribedAsFacet describedAsFacet, int index = -1)
     : base(Type, holder) {
     this.manager = manager;
     this.identifier = identifier;
     this.describedAsFacet = describedAsFacet;
     this.index = index;
 }

 /// <summary>
 ///     Returns a <see cref="IFacetsFacet" /> impl provided that at least one valid
 ///     factory <see cref="IFacetsFacet.FacetFactories" /> was specified.
 /// </summary>
 private static IFacetsFacet Create(FacetsAttribute attribute, IFacetHolder holder) {
     if (attribute == null) {
         return null;
     }
     var facetsFacetAnnotation = new FacetsFacetAnnotation(attribute, holder);
     return facetsFacetAnnotation.FacetFactories.Length > 0 ? facetsFacetAnnotation : null;
 }

 public SecurityHideForSessionFacet(IIdentifier identifier,
                                    SecurityFacetDecorator decorator,
                                    IFacetHolder holder)
     : base(holder) {
     this.identifier = identifier;
     this.decorator = decorator;
 }

        /// <summary>
        ///     Returns a <see cref="IValueFacet" /> implementation.
        /// </summary>
        private static IValueFacet Create(Type type, IFacetHolder holder) {
            // create from annotation, if present
            var annotation = type.GetCustomAttributeByReflection<ValueAttribute>();
            if (annotation != null) {
                if (annotation.SemanticsProviderClass != null || annotation.SemanticsProviderName.Length != 0) {
                    Type annotationType = annotation.SemanticsProviderClass;
                    if (annotationType == null && !string.IsNullOrEmpty(annotation.SemanticsProviderName)) {
                        annotationType = TypeUtils.GetType(annotation.SemanticsProviderName);
                    }
                    PropertyInfo method = annotationType.GetProperty("Parser");
                    Type propertyType = method.PropertyType.GetGenericArguments()[0];
                    if (!propertyType.IsAssignableFrom(type)) {
                        throw new ModelException(string.Format(Resources.NakedObjects.SemanticProviderMismatch, type, propertyType, holder.Identifier.ClassName));
                    }
                }

                var facet = TypeUtils.CreateGenericInstance<IValueFacet>(typeof (ValueFacetAnnotation<>),
                                                                         new[] {type},
                                                                         new object[] {type, holder});
                if (facet.IsValid) {
                    return facet;
                }
            }


            return null;
        }

 public ActionChoicesFacetViaMethod(MethodInfo choicesMethod, Type choicesType, IFacetHolder holder, bool isMultiple = false)
     : base(holder) {
     this.choicesMethod = choicesMethod;
     this.choicesType = choicesType;
     this.isMultiple = isMultiple;
     parameterNamesAndTypes = choicesMethod.GetParameters().Select(p => new Tuple<string, INakedObjectSpecification>(p.Name.ToLower(), NakedObjectsContext.Reflector.LoadSpecification(p.ParameterType))).ToArray();
     parameterNames = parameterNamesAndTypes.Select(pnt => pnt.Item1).ToArray();
 }

        public NamedFacetDynamicWrapI18n(II18nManager manager, IFacetHolder holder, IIdentifier identifier, INamedFacet namedFacet, int index = -1)
            : base(Type, holder) {
            this.manager = manager;
            this.identifier = identifier;
            this.namedFacet = namedFacet;

            this.index = index;
        }

 public override bool ProcessParams(MethodInfo method, int paramNum, IFacetHolder holder) {
     ParameterInfo parameter = method.GetParameters()[paramNum];
     Attribute attribute = parameter.GetCustomAttributeByReflection<DescriptionAttribute>();
     if (attribute == null) {
         attribute = parameter.GetCustomAttributeByReflection<DescribedAsAttribute>();
     }
     return FacetUtils.AddFacet(Create(attribute, holder));
 }

 private static bool Process(MemberInfo member, IFacetHolder holder) {
     var attribute = member.GetCustomAttribute<DisabledAttribute>();
     IDisabledFacet disabledFacet = Create(attribute, holder);
     if (disabledFacet != null) {
         return FacetUtils.AddFacet(disabledFacet);
     }
     return false;
 }

 private static bool Process(Func<Attribute> getHidden, Func<Attribute> getScaffold, IFacetHolder holder) {
     Attribute attribute = getHidden();
     if (attribute != null) {
         return FacetUtils.AddFacet(Create((HiddenAttribute) attribute, holder));
     }
     attribute = getScaffold();
     return FacetUtils.AddFacet(Create((ScaffoldColumnAttribute) attribute, holder));
 }

 public static bool IsVisible(IFacetHolder facetHolder, InteractionContext ic) {
     var buf = new InteractionBuffer();
     IFacet[] facets = facetHolder.GetFacets(FacetFilters.IsA(typeof (IHidingInteractionAdvisor)));
     foreach (IHidingInteractionAdvisor advisor in facets) {
         buf.Append(advisor.Hides(ic));
     }
     return IsVisible(buf);
 }