/// <summary>
 /// Creates a new <see cref="pMixinAttributeResolvedResult"/>
 /// </summary>
 /// <param name="attribute">
 /// Reference to the <see cref="CopaceticSoftware.pMixin"/>'s source code.
 /// </param>
 public pMixinAttributeResolvedResult(IAttribute attribute)
     : base(attribute)
 {
     Masks = new List<IType>(0);
     Interceptors = new List<IType>(0);
     EnableSharedRequirementsInterface = new pMixinAttribute().EnableSharedRequirementsInterface;
 }

 private static IAssociations GetTargetModifierList(IAttribute target, string modifierType)
 {
     switch (modifierType)
     {
         case "ModAdd":
             return target.AdditionAssociations;
         case "ModSub":
             return target.SubstractionAssociations;
         case "PostAssignment":
             return target.PostAssignmentAssociations;
         case "PostDiv":
             return target.PostDivisionAssociations;
         case "PostMul":
             return target.PostMultiplicationAssociations;
         case "PostPercent":
             return target.PostPercentAssociations;
         case "PreAssignment":
             return target.PreAssignmentAssociations;
         case "PreDiv":
             return target.PreDivisionAssociations;
         case "PreMul":
             return target.PreMultiplicationAssociations;
         case "9":
             //skilllevel modifier
             return new DummyAssociations();
         default://TODO richtiger exceptiontyp
             throw new Exception("unknown modifier type: " + modifierType);
     }
 }

		public IList<IAttribute> Resolve(IAssembly currentAssembly)
		{
			// TODO: make this a per-assembly cache
//				CacheManager cache = currentAssembly.Compilation.CacheManager;
//				IList<IAttribute> result = (IList<IAttribute>)cache.GetShared(this);
//				if (result != null)
//					return result;
			
			ITypeResolveContext context = new SimpleTypeResolveContext(currentAssembly);
			BlobReader reader = new BlobReader(blob, currentAssembly);
			if (reader.ReadByte() != '.') {
				// should not use UnresolvedSecurityDeclaration for XML secdecls
				throw new InvalidOperationException();
			}
			ResolveResult securityActionRR = securityAction.Resolve(context);
			uint attributeCount = reader.ReadCompressedUInt32();
			IAttribute[] attributes = new IAttribute[attributeCount];
			try {
				ReadSecurityBlob(reader, attributes, context, securityActionRR);
			} catch (NotSupportedException) {
				// ignore invalid blobs
				//Debug.WriteLine(ex.ToString());
			}
			for (int i = 0; i < attributes.Length; i++) {
				if (attributes[i] == null)
					attributes[i] = new CecilResolvedAttribute(context, SpecialType.UnknownType);
			}
			return attributes;
//				return (IList<IAttribute>)cache.GetOrAddShared(this, attributes);
		}

 private ConditionalExpression GetConditionalResourceExpression(IAttribute fromAttribute)
 {
     string targetResource = fromAttribute.GetTextValue();
     string nullCheck = _syntaxProvider.CreateNullCheckExpression(targetResource);
     string uriExpression = _syntaxProvider.CreateUriExpression(targetResource);
     return new ConditionalExpression(nullCheck, uriExpression);
 }

 public void Modify(IAttribute originalAttribute, IAttribute newAttribute)
 {
     ICodeExpressionNode codeExpressionNode = newAttribute.AddCodeExpressionNode();
     codeExpressionNode.SetExpressionBody(new CodeExpression("true"));
     IConditionalExpressionNodeWrapper conditionalExpressionNodeWrapper = newAttribute.AddConditionalExpressionNode();
     conditionalExpressionNodeWrapper.SetExpressionBody(new ConditionalExpression(_syntaxProvider.CreateNullCheckAndEvalExpression(originalAttribute.GetTextValue()), originalAttribute.GetTextValue()));
 }

 protected virtual void WriteAttribute(IXhtmlWriter writer, IAttribute attribute)
 {
     if (!attribute.IsDefault || attribute.RendersOnDefaultValue)
     {
         writer.WriteAttributeString(attribute.Name.ToLowerInvariant(), attribute.SerializedValue);
     }
 }

 internal EventInfo(Type declaringType, string name, MethodInfo addMethod, MethodInfo removeMethod, IAttribute[] attributes)
 {
     _declaringType = declaringType;
     _name = name;
     _addMethod = addMethod;
     _removeMethod = removeMethod;
     _attributes = attributes;
 }

 public void Modify(IAttribute originalAttribute, IAttribute newAttribute)
 {
     ICodeExpressionNode node = newAttribute.AddCodeExpressionNode();
     string expression = _syntaxProvider.CreateGetPropertyPathExpression(originalAttribute.GetTextValue());
     node.SetExpressionBody(
         new CodeExpression(expression)
         );
 }

		public override void AddAssemblyAttribute(IProject targetProject, IAttribute attribute)
		{
			// FIXME : will fail if there are no assembly attributes
			ICompilation compilation = SD.ParserService.GetCompilation(targetProject);
			IAttribute target = compilation.MainAssembly.AssemblyAttributes.LastOrDefault();
			if (target == null)
				throw new InvalidOperationException("no assembly attributes found, cannot continue!");
			AddAttribute(target.Region, attribute, "assembly");
		}

 public bool TryAttribute(string name, out IAttribute attr) {
     if (Attributes.Any()) {
         if (Attributes.Exists(a => a.Name == name)) {
             attr = Attributes.First(a => a.Name == name);
             return true;
         }
     }
     attr = null;
     return false;
 }

        public IAttributeValue CreateValue(IAttribute attribute, String value)
        {
            //            checkArgument(value != null, "Value cannot be null.");
            throw new NotImplementedException();
            //AttributeValue rv = new AttributeValue(attribute);
            //rv.setValue(value);
            //_List.Add(rv);

            //return rv;
        }

 public static bool IsRefined(this IClass @class, IAttribute attribute)
 {
     var refine = @class.AttributeConstraints.Any(c => c.Constrains == attribute) || @class.Attributes.Any(r => r.Refines == attribute);
     if (refine) return true;
     foreach (var baseType in @class.BaseTypes)
     {
         if (baseType == attribute.DeclaringType) return false;
         if (IsRefined(baseType, attribute)) return true;
     }
     return false;
 }

		public void CreateAttribute(string fullName, string shortName)
		{
			var returnTypeHelper = new ReturnTypeHelper();
			returnTypeHelper.CreateReturnType(fullName);
			returnTypeHelper.AddShortName(shortName);
			AttributeType = returnTypeHelper.ReturnType;
			
			Attribute = MockRepository.GenerateStub<IAttribute>();
			Attribute.Stub(a => a.AttributeType).Return(AttributeType);
			Attribute.Stub(a => a.PositionalArguments).Return(PositionalArguments);
			Attribute.Stub(a => a.NamedArguments).Return(NamedArguments);
		}

 public static string ToString(IAttribute attribute)
 {
     var builder = new StringBuilder();
     var attributeType = attribute.GetType();
     builder.Append("  - ").Append(attributeType.Name).AppendLine();
     foreach (var eachProperty in attributeType.GetProperties())
     {
         var propertyValue = eachProperty.GetValue(attribute);
         builder.Append("    - ").Append(eachProperty.Name).Append('=').Append(propertyValue).AppendLine();
     }
     return builder.ToString();
 }

        public static void Assign(this IAttribute attribute, IAttribute other)
        {
            Debug.Assert(attribute != null);
            if (other == null)
                return;

            Debug.Assert(attribute.GetType() == other.GetType());
            foreach (var eachProperty in attribute.GetType().GetProperties())
            {
                eachProperty.SetValue(attribute, eachProperty.GetValue(other));
            }
        }

        private static object ApplyMinConstraints(ConstraintsAttribute constraints, object newValue, IAttribute attribute, PropertyInfo propertyInfo)
        {
            switch (constraints.ValueType)
            {
                case ConstraintsValueType.IntValue:
                    return Math.Max(newValue.As<int>(), constraints.IntValue);

                case ConstraintsValueType.FloatValue:
                    return Math.Max(newValue.As<float>(), constraints.FloatValue);

                case ConstraintsValueType.Reference:
                    return Math.Max(newValue.As<float>(), propertyInfo.GetValue(attribute).As<float>());
            }
            throw new InvalidOperationException("invalid value-type for max constraints: " + constraints.ValueType);
        }

        public static IAttribute GetCustomAttribute(IAttribute attribute, INode parent, IQualifiedName name, string value)
        {
            var attributeName = attribute.Name.ToString();

            if (!customAttributeFactories.ContainsKey(attributeName))
                return null;

            foreach (var factory in customAttributeFactories[attributeName])
            {
                if (factory.IsValidFor(attribute))
                    return factory.Create(parent, name, value);
            }

            return null;
        }

        public virtual int CompareTo(IAttribute value)
        {
            int cmp;

            cmp = Name.CompareTo(value.Name);
            if (cmp != 0) {
                return cmp;
            }

            cmp = DiffUtility.Compare(PositionalArguments, value.PositionalArguments);
            if (cmp != 0) {
                return cmp;
            }

            return DiffUtility.Compare(NamedArguments, value.NamedArguments);
        }

 public static ICollection<string> GetAttributeConstraintValue(this IClass referenceClass, IAttribute attribute)
 {
     var attRefinement = referenceClass.AttributeConstraints.FirstOrDefault(c => c.Constrains == attribute);
     if (attRefinement != null)
     {
         return attRefinement.Values;
     }
     foreach (var baseClass in referenceClass.BaseTypes)
     {
         var value = baseClass.GetAttributeConstraintValue(attribute);
         if (value != null)
         {
             return value;
         }
     }
     return null;
 }

 public bool IsAvailable(IUserDataHolder cache)
 {
     _propertyAssignment = null;
     _dllImportAttribute = null;
     Func<IAttribute, bool> isDllImportAttribute = a =>
     {
         var typeReference = a.TypeReference;
         if (typeReference != null)
         {
             var typeElement = typeReference.Resolve().DeclaredElement as ITypeElement;
             if (typeElement != null && Equals(typeElement.GetClrName(), DllImportMissingAnalyzer.DllImportAttribute))
             {
                 return true;
             }
         }
         return false;
     };
     var method = _provider.GetSelectedElement<IMethodDeclaration>(true, true);
     if (method == null)
     {
         return false;
     }
     var attribute = method.Attributes.FirstOrDefault(isDllImportAttribute);
     if (attribute == null || !attribute.IsValid())
     {
         return false;
     }
     _dllImportAttribute = attribute;
     var entryPoint = attribute.PropertyAssignments.FirstOrDefault(pa => pa.PropertyNameIdentifier.Name == "EntryPoint");
     if (entryPoint == null)
     {
         return true;
     }
     _propertyAssignment = entryPoint;
     var literal = entryPoint.Source as ICSharpLiteralExpression;
     if (literal != null)
     {
         if (!literal.IsConstantValue())
         {
             return true;
         }
         var value = literal.ConstantValue.Value as string;
         return value != method.NameIdentifier.Name;
     }
     return false;
 }