Exemple #1
0
 public override bool Matches(
     Type returnType, ParameterInfo[] parameters,
     DefinitionAttribute attribute,
     IDictionary <string, Type> aliases)
 {
     if (typeof(Promise).IsAssignableFrom(returnType))
     {
         var promiseType = returnType.GetOpenTypeConformance(typeof(Promise <>));
         returnType = promiseType != null
                    ? promiseType.GetGenericArguments()[0]
                    : typeof(object);
     }
     else if (typeof(Task).IsAssignableFrom(returnType))
     {
         var taskType = returnType.GetOpenTypeConformance(typeof(Task <>));
         returnType = taskType != null
                    ? taskType.GetGenericArguments()[0]
                    : typeof(object);
     }
     else if (_required)
     {
         return(false);
     }
     return(base.Matches(returnType, parameters, attribute, aliases));
 }
Exemple #2
0
 public override bool Matches(
     Type returnType, ParameterInfo[] parameters,
     DefinitionAttribute attribute,
     IDictionary <string, Type> aliases)
 {
     return(Rule.Matches(returnType, parameters, attribute, aliases));
 }
Exemple #3
0
 public override bool Matches(
     Type returnType, ParameterInfo[] parameters,
     DefinitionAttribute attribute,
     IDictionary <string, Type> aliases)
 {
     return(returnType.IsClassOf(_type));
 }
        public override bool Matches(
            ParameterInfo parameter, DefinitionAttribute attribute,
            IDictionary <string, Type> aliases)
        {
            var paramType = parameter.ParameterType;

            return(typeof(IHandler).IsAssignableFrom(paramType));
        }
        public override PolicyMethodBinding BindMethod(
            MethodRule rule, MethodDispatch dispatch,
            DefinitionAttribute attribute)
        {
            var binding = base.BindMethod(rule, dispatch, attribute);

            InferVariance(binding);
            return(binding);
        }
        public void fillComponents(DataGridView grid)
        {
            grid.Rows.Clear();
            foreach (IComponent c in Loader.Soba.Registered)
            {
                Type type = c.GetType();
                if (!Inspector.IsComponent(type))
                {
                    continue;
                }

                bool   enabled   = c.Enabled;
                string className = c.GetType().Name;

                Component v = SlnEvents.Components?.FirstOrDefault(p => p.ClassName == className);
                if (v != null)
                {
                    enabled = v.Enabled;
                }

                cInfo[className] = new List <INodeInfo>();
                bool withoutAttr = true;

                foreach (Attribute attr in type.GetCustomAttributes(true))
                {
                    if (attr.GetType() == typeof(ComponentAttribute) || attr.GetType() == typeof(DefinitionAttribute))
                    {
                        withoutAttr = false;
                    }

                    if (attr.GetType() == typeof(ComponentAttribute) && ((ComponentAttribute)attr).Parent == null)
                    {
                        fillComponents((ComponentAttribute)attr, enabled, className, grid);
                    }
                    else if (attr.GetType() == typeof(DefinitionAttribute) && ((DefinitionAttribute)attr).Parent == null)
                    {
                        DefinitionAttribute def = (DefinitionAttribute)attr;
                        grid.Rows.Add(DomIcon.definition, enabled, def.Name, className, def.Description);
                    }
                    else if (((DefinitionAttribute)attr).Parent != null)
                    {
                        cInfo[className].Add(new NodeInfo((DefinitionAttribute)attr));
                    }
                    else if (((ComponentAttribute)attr).Parent != null)
                    {
                        cInfo[className].Add(new NodeInfo((ComponentAttribute)attr));
                    }
                }

                if (withoutAttr)
                {
                    grid.Rows.Add(DomIcon.package, enabled, String.Empty, className, String.Empty);
                }
                cInfo[className].AddRange(new List <INodeInfo>(domElemsBy(className)));
            }
            grid.Sort(grid.Columns[2], System.ComponentModel.ListSortDirection.Descending);
        }
        public static bool TryGetDefinition(this PropertyInfo property, out string definition)
        {
            definition = null;
            DefinitionAttribute def = property.GetCustomAttribute <DefinitionAttribute>();

            if (def.Exists())
            {
                definition = def.Definition;
                return(true);
            }
            return(false);
        }
Exemple #8
0
        public PolicyMethodBinding Bind(MethodDispatch dispatch, DefinitionAttribute attribute)
        {
            var binding = _binder(this, dispatch, attribute);

            _returnValue?.Configure(binding);
            var parameters = dispatch.Method.GetParameters();

            for (var i = 0; i < parameters.Length; ++i)
            {
                _args[i].Configure(parameters[i], binding);
            }
            return(binding);
        }
Exemple #9
0
        public override bool Matches(
            ParameterInfo parameter, DefinitionAttribute attribute,
            IDictionary <string, Type> aliases)
        {
            var paramType = parameter.ParameterType;

            if (typeof(Res).IsAssignableFrom(paramType))
            {
                if (_alias != null)
                {
                    aliases.Add(_alias, paramType);
                }
                return(true);
            }
            return(false);
        }
 public PolicyMethodBinding(MethodRule rule,
                            MethodDispatch dispatch,
                            DefinitionAttribute attribute,
                            CallbackPolicy policy)
     : base(dispatch)
 {
     if (rule == null)
     {
         throw new ArgumentNullException(nameof(rule));
     }
     if (dispatch == null)
     {
         throw new ArgumentNullException(nameof(dispatch));
     }
     Rule      = rule;
     Attribute = attribute;
     Policy    = policy;
 }
Exemple #11
0
        public bool Matches(MethodInfo method, DefinitionAttribute attribute)
        {
            var parameters = method.GetParameters();
            var paramCount = parameters.Length;
            var aliases    = new Dictionary <string, Type>();

            if (paramCount < _minArgs || paramCount > _args.Length ||
                !parameters.Zip(_args, (param, arg) => arg.Matches(param, attribute, aliases))
                .All(m => m))
            {
                return(false);
            }
            if (_returnValue?.Matches(method.ReturnType, parameters, attribute, aliases) == false)
            {
                throw new InvalidOperationException(
                          $"Method '{method.GetDescription()} satisfied the arguments but rejected the return'");
            }
            return(true);
        }
Exemple #12
0
        public override bool Matches(
            ParameterInfo parameter, DefinitionAttribute attribute,
            IDictionary <string, Type> aliases)
        {
            var paramType = parameter.ParameterType;

            if (_type.IsAssignableFrom(paramType))
            {
                if (_aliases != null && _aliases.Length > 0)
                {
                    throw new InvalidOperationException(
                              $"{_type.FullName} is not a generic definition and cannot bind aliases");
                }
                return(base.Matches(parameter, attribute, aliases));
            }
            var openGeneric = paramType.GetOpenTypeConformance(_type);

            if (openGeneric == null)
            {
                return(false);
            }
            if (_aliases == null || _aliases.Length == 0)
            {
                return(true);
            }
            var genericArgs = openGeneric.GetGenericArguments();

            if (_aliases.Length > genericArgs.Length)
            {
                throw new InvalidOperationException(
                          $"{_type.FullName} has {genericArgs.Length} generic args, but {_aliases.Length} requested");
            }
            for (var i = 0; i < _aliases.Length; ++i)
            {
                var alias = _aliases[i];
                if (!string.IsNullOrEmpty(alias))
                {
                    aliases.Add(_aliases[i], genericArgs[i]);
                }
            }
            return(base.Matches(parameter, attribute, aliases));
        }
        public override bool Matches(
            ParameterInfo parameter, DefinitionAttribute attribute,
            IDictionary <string, Type> aliases)
        {
            var paramType = parameter.ParameterType;

            if (typeof(Cb).IsAssignableFrom(paramType))
            {
                return(false);
            }
            if (paramType.IsGenericParameter)
            {
                var contraints = paramType.GetGenericParameterConstraints();
                switch (contraints.Length)
                {
                case 0:
                    paramType = typeof(object);
                    break;

                case 1:
                    paramType = contraints[0];
                    break;

                default:
                    return(false);
                }
            }
            var restrict = attribute.Key as Type;

            if (restrict == null || restrict.IsAssignableFrom(paramType) ||
                paramType.IsAssignableFrom(restrict))
            {
                if (_alias != null)
                {
                    aliases.Add(_alias, paramType);
                }
                return(true);
            }
            throw new InvalidOperationException(
                      $"Key {restrict.FullName} is not related to {paramType.FullName}");
        }
Exemple #14
0
        public override bool Matches(
            Type returnType, ParameterInfo[] parameters,
            DefinitionAttribute attribute,
            IDictionary <string, Type> aliases)
        {
            if (IsLogicalVoid(returnType))
            {
                return(false);
            }
            if (returnType.IsArray)
            {
                returnType = returnType.GetElementType();
            }
            var restrict = attribute.Key as Type;

            if (restrict == null || restrict.IsAssignableFrom(returnType) ||
                returnType.IsAssignableFrom(restrict))
            {
                return(true);
            }
            throw new InvalidOperationException(
                      $"Key {restrict.FullName} is not related to {returnType.FullName}");
        }
        /// <summary> Write a Definition XML Element from attributes in a member. </summary>
        public virtual void WriteDefinition(System.Xml.XmlWriter writer, System.Reflection.MemberInfo member, DefinitionAttribute attribute, BaseAttribute parentAttribute, System.Type mappedClass)
        {
            writer.WriteStartElement( "definition" );
            // Attribute: <class>
            writer.WriteAttributeString("class", attribute.Class==null ? DefaultHelper.Get_Definition_Class_DefaultValue(member) : GetAttributeValue(attribute.Class, mappedClass));

            WriteUserDefinedContent(writer, member, null, attribute);

            System.Collections.ArrayList memberAttribs = GetSortedAttributes(member);
            int attribPos; // Find the position of the DefinitionAttribute (its <sub-element>s must be after it)
            for(attribPos=0; attribPos<memberAttribs.Count; attribPos++)
                if( memberAttribs[attribPos] is DefinitionAttribute
                    && ((BaseAttribute)memberAttribs[attribPos]).Position == attribute.Position )
                    break; // found
            int i = attribPos + 1;

            // Element: <param>
            for(; i<memberAttribs.Count; i++)
            {
                BaseAttribute memberAttrib = memberAttribs[i] as BaseAttribute;
                if( IsNextElement(memberAttrib, parentAttribute, attribute.GetType())
                    || IsNextElement(memberAttrib, attribute, typeof(ParamAttribute)) )
                    break; // next attributes are 'elements' of the same level OR for 'sub-elements'
                else
                {
                    if( memberAttrib is DefinitionAttribute )
                        break; // Following attributes are for this Definition
                    if( memberAttrib is ParamAttribute )
                        WriteParam(writer, member, memberAttrib as ParamAttribute, attribute, mappedClass);
                }
            }
            WriteUserDefinedContent(writer, member, typeof(ParamAttribute), attribute);

            writer.WriteEndElement();
        }
Exemple #16
0
 public virtual PolicyMethodBinding BindMethod(MethodRule rule,
                                               MethodDispatch dispatch, DefinitionAttribute attribute)
 {
     return(Binder?.Invoke(rule, dispatch, attribute, this)
            ?? new PolicyMethodBinding(rule, dispatch, attribute, this));
 }
Exemple #17
0
 public abstract bool Matches(
     Type returnType, ParameterInfo[] parameters,
     DefinitionAttribute attribute,
     IDictionary <string, Type> aliases);
Exemple #18
0
 public abstract bool Matches(
     ParameterInfo parameter, DefinitionAttribute attribute,
     IDictionary <string, Type> aliases);
        /// <summary> Write a Definition XML Element from attributes in a member. </summary>
        public virtual void WriteDefinition(System.Xml.XmlWriter writer, System.Reflection.MemberInfo member, DefinitionAttribute attribute, BaseAttribute parentAttribute, System.Type mappedClass)
        {
            writer.WriteStartElement( "definition" );
            // Attribute: <class>
            writer.WriteAttributeString("class", attribute.Class==null ? DefaultHelper.Get_Definition_Class_DefaultValue(member) : GetAttributeValue(attribute.Class, mappedClass));

            WriteUserDefinedContent(writer, member, null, attribute);

            writer.WriteEndElement();
        }
Exemple #20
0
 public override bool Matches(
     ParameterInfo parameter, DefinitionAttribute attribute,
     IDictionary <string, Type> aliases)
 {
     return(Argument.Matches(parameter, attribute, aliases));
 }
Exemple #21
0
 public MethodRule MatchMethod(MethodInfo method, DefinitionAttribute attribute)
 {
     return(_rules.FirstOrDefault(r => r.Matches(method, attribute)));
 }
 /// <param name="attr">Attribute of property</param>
 /// <param name="displaying">Displays element over the 'Name' property</param>
 public NodeInfo(DefinitionAttribute attr, string displaying = null)
     : this(attr.Name, attr.Description, new NodeIdent(attr.Name, null), InfoType.Definition, displaying)
 {
 }