Esempio n. 1
0
    private bool PartOfImplementation(object[] args, PartialOutput o, BindingEnvironment e, Step.Interpreter.Step.Continuation k)
    {
        // [PartOf ?container ?partName ?partIndividual]
        ArgumentCountException.Check("PartOf", 3, args);
        CheckArgument <PossibleIndividual>("PartOf", args[0], e, args, out var containerValue, out var containerVariable);
        var partArg = args[1];

        // ReSharper disable UnusedVariable
        CheckArgument <Part>("PartOf", partArg, e, args, out var partTypeValue, out var partTypeVariable);
        // ReSharper restore UnusedVariable
        CheckArgument <PossibleIndividual>("PartOf", args[2], e, args, out var partValue, out var partVariable);
        if (containerVariable == null)
        {
            // container in
            if (partVariable == null)
            {
                // part in
                return(partValue.Individual.Container == containerValue.Individual &&
                       e.Unify(partArg, partValue.Individual.ContainerPart, e.Unifications, out var bindings) &&
                       k(o, bindings, e.State));
            }
            else
            {
                var invention = containerValue.Invention;
                // Container in, part out
                foreach (var pair in containerValue.Individual.Parts)
                {
                    foreach (var partIndividual in pair.Value)
                    {
                        var possibleIndividual = invention.PossibleIndividual(partIndividual);
                        var part = partIndividual.ContainerPart;
                        if (e.Unify(part, partArg, e.Unifications, out var bindings) &&
                            k(o, bindings.Bind(partVariable, possibleIndividual), e.State))
                        {
                            return(true);
                        }
                    }
                }

                return(false);
            }
        }

        // container out
        if (partVariable == null)
        {
            var invention = partValue.Invention;
            // part in
            return(e.Unify(partArg, partValue.Individual.ContainerPart, e.Unifications, out var bindingList) &&
                   k(o, bindingList.Bind(containerVariable, invention.PossibleIndividual(partValue.Individual.Container)),
                     e.State));
        }

        // container out, part out
        throw new ArgumentInstantiationException("PartOf", e, args);
    }
Esempio n. 2
0
        /// <summary>
        /// Find all tasks that contain the specified string in their name, arglists, or documentation, and print their documentation.
        /// </summary>
        private static bool Apropos(object[] args, TextBuffer o, BindingEnvironment e,
                                    MethodCallFrame predecessor, Interpreter.Step.Continuation k)
        {
            ArgumentCountException.Check(nameof(Apropos), 1, args);
            var topic  = ArgumentTypeException.Cast <string>(nameof(Apropos), args[0], args);
            var output = new StringBuilder();

            bool Relevant(string x) => x != null && x.IndexOf(topic, StringComparison.InvariantCultureIgnoreCase) >= 0;

            var module = e.Module;

            foreach (var binding in module.AllBindings)
            {
                if (binding.Value is Task t && (Relevant(binding.Key.Name) || Relevant(t.Description)))
                {
                    output.Append(ManualEntryMaybeRichText(t));
                    output.Append("\n\n");
                }
            }

            return(k(o.Append(output.ToString()), e.Unifications, e.State, predecessor));
        }