Пример #1
0
 public DynamicKnowledgeEntry(DynamicPropertyCalculator surogate, Name[] parameters, string description, Type declaringType)
 {
     _surogate     = surogate;
     _parameters   = parameters;
     Description   = description;
     DeclaringType = declaringType;
 }
            public static IEnumerable <TestCaseData> Test_OperatorRegist_Cases()
            {
                DynamicPropertyCalculator p = (kb2, pers, args, subs) =>
                {
                    return(Enumerable.Empty <Pair <PrimitiveValue, SubstitutionSet> >());
                };

                yield return(new TestCaseData(PopulatedTestMemory(), (Name)"Count([x])", p, (Name)"Count(IsAlive([x]))", null));

                yield return(new TestCaseData(PopulatedTestMemory(), (Name)"Count([x])", p, (Name)"Count([y])", new SubstitutionSet(new Substitution("[y]/IsAlive([x])"))));
            }
Пример #3
0
        public void RegistDynamicProperty(Name propertyTemplate, DynamicPropertyCalculator surogate, IEnumerable <string> arguments)
        {
            if (surogate == null)
            {
                throw new ArgumentNullException(nameof(surogate));
            }

            if (propertyTemplate.IsGrounded)
            {
                throw new ArgumentException("Grounded names cannot be used as dynamic properties", nameof(propertyTemplate));
            }

            var r = m_dynamicProperties.Unify(propertyTemplate).FirstOrDefault();

            if (r != null)
            {
                throw new ArgumentException(
                          $"The given template {propertyTemplate} will collide with already registed {propertyTemplate.MakeGround(r.Item2)} dynamic property", nameof(propertyTemplate));
            }

            if (m_knowledgeStorage.Unify(propertyTemplate).Any())
            {
                throw new ArgumentException($"The given template {propertyTemplate} will collide with stored constant properties", nameof(propertyTemplate));
            }

            Name[] args;
            if (arguments == null)
            {
                args = new Name[0];
            }
            else
            {
                args = arguments.Distinct().Select(s => Name.BuildName("[" + s + "]")).ToArray();
            }
            m_dynamicProperties.Add(propertyTemplate, new DynamicKnowledgeEntry(surogate, args));
        }
Пример #4
0
 public DynamicKnowledgeEntry(DynamicPropertyCalculator surogate, Name[] arguments)
 {
     this.surogate  = surogate;
     this.arguments = arguments;
 }
Пример #5
0
        private void internal_RegistDynamicProperty(Name propertyName, MethodInfo surogate, DynamicPropertyCalculator converted)
        {
            if (!propertyName.IsPrimitive)
            {
                throw new ArgumentException("The property name must be a primitive symbol.", nameof(propertyName));
            }

            var p = surogate.GetParameters();
            var propertyParameters = p.Skip(1).Select(p2 => Name.BuildName("[" + p2.Name + "]")).ToArray();
            var template           = Name.BuildName(propertyParameters.Prepend(propertyName));

            var r = m_dynamicProperties.Unify(template).FirstOrDefault();

            if (r != null)
            {
                var t = r.Item1.DeclaringType;
                if (t == surogate.DeclaringType)
                {
                    return;
                }

                throw new ArgumentException("There is already a registed property with the name " + propertyName + " that receives " + (p.Length - 3) + "parameters.");
            }

            if (_willCollideDelegate(template))
            {
                throw new ArgumentException("There are already stored property values that will collide with the given dynamic property.");
            }

            m_dynamicProperties.Add(template, new DynamicKnowledgeEntry(converted, propertyParameters, surogate.DeclaringType));
        }
        private void internal_RegistDynamicProperty(Name propertyName, string description, MethodInfo surogate, DynamicPropertyCalculator converted)
        {
            if (!propertyName.IsPrimitive)
                throw new ArgumentException("The property name must be a primitive symbol.", nameof(propertyName));

            var p = surogate.GetParameters();
            var propertyParameters = p.Skip(1).Select(p2 => (Name) $"[{p2.Name}]").ToArray();
            var template = Name.BuildName(propertyParameters.Prepend(propertyName));

            var r = m_dynamicProperties.Unify(template).FirstOrDefault();
            if (r != null)
                throw new ArgumentException($"There is already a registed property with the name {propertyName} that receives {p.Length - 3} parameters.");

            if (m_knowledgeStorage.Unify(template).Any())
                throw new ArgumentException($"There are already stored property values that will collide with the given dynamic property.");

            m_dynamicProperties.Add(template, new DynamicKnowledgeEntry(converted,propertyParameters, description));
        }
 public DynamicKnowledgeEntry(DynamicPropertyCalculator surogate, Name[] parameters, string description)
 {
     _surogate = surogate;
     _parameters = parameters;
     this.description = description;
 }