C# Context.LookupDefaulted方法代码示例

        public static List<IContent> GetStarValue(Context context, string name)
        {
            if (name.Length == 1)
                return GetStarValue(context, name + "1");

            return context.LookupDefaulted<List<IContent>>(name, new List<IContent>());
        }

 public static string NextStarName(Context context, string prefix)
 {
     string prevStarName = prefix + "#";
     int prevStarCount = context.LookupDefaulted<int>(prevStarName, 0);
     context.Map[prevStarName] = prevStarCount + 1;
     return prefix + (prevStarCount + 1).ToString();
 }

        public override bool Produce(Context context, IContinuation succ, IFailure fail)
        {
            object var = context.LookupDefaulted<object>("$p$" + name, null);

            if (var is IParsedPhrase)
                succ.Continue((IParsedPhrase)var, fail);

            succ.Continue(null, fail);

            return true;
        }

        public override bool Match(object check, Context context, IContinuation succ, IFailure fail)
        {
            if (!(check is IParsedPhrase)) {
                fail.Fail("Cannot match a " + check.GetType(), succ);
                return true;
            }

            // Set up main check
            IParsedPhrase full = (IParsedPhrase) check;

            GroupPhrase sofar = context.LookupDefaulted<GroupPhrase>("$active$" + name, null);
            if (sofar != null)
                full = sofar.AddBranch(full);

            bool? isMatch = IsMatch(full);

            if (!isMatch.HasValue) {
                List<IContent> contents = new List<IContent>();
                contents.Add(new Value(this));
                Context tryagain = new Context(context, contents);
                tryagain.Map["$active$" + name] = new GroupPhrase(full);
                // Continue with same context
                succ.Continue(tryagain, fail);
            } else {
                if (isMatch.Value) {
                    Propogate(context, full, 1.0);
                    context.Map[StarUtilities.NextStarName(context, name)] = full.Text;

                    succ.Continue(context.ChildRange(1), fail);
                } else {
                    fail.Fail("Does not match " + full.Text, succ);
                }
            }

            return true;
        }

        public virtual IParsedPhrase Produce(Context env, POSTagger tagger, GrammarParser parser)
        {
            object var = env.LookupDefaulted<object>("$p$" + name, null);
            if (var is ThreeTuple<GetValue, object, object[]>)
            {
                ThreeTuple<GetValue, object, object[]> tuple = (ThreeTuple<GetValue, object, object[]>)var;
                var = tuple.one(tuple.two, tuple.three);
            }

            if (var is IParsedPhrase)
                return (IParsedPhrase)var;
            else if (var is Concept)
                return ConceptToPhrase(env, (Concept)var, tagger, parser);

            return null;    // don't produce anything!
        }

        public virtual void Propogate(Context env, object matched, double strength)
        {
            //object myMatched = env.LookupDefaulted<object>("$p$" + name, null);
            double myStrength = env.LookupDefaulted<double>("$s$" + name, 0.0);

            if (myStrength < strength)
            {
                env.Map["$p$" + name] = matched;
                env.Map["$s$" + name] = strength;
            }
        }

        public Concept CompletePartials(Context context)
        {
            if (context.Contents.Count == 0)
                return null;

            IParsedPhrase phrase = StarUtilities.ProducedPhrase(context, tagger, parser);
            if (phrase == null)
            {
                // cannot do!
                context.Map["$knowPartials"] = new List<Datum>();
                return null;
            }
            Concept concept = memory.NewConcept(phrase);

            List<Datum> completes = context.LookupAndAdd<List<Datum>>("$knowCompletes", new List<Datum>());

            List<Datum> data = context.LookupDefaulted<List<Datum>>("$knowPartials", new List<Datum>());
            foreach (Datum datum in data)
                completes.Add(memory.Know(concept, datum));

            context.Map["$knowPartials"] = new List<Datum>();

            return concept;
        }

        public void NextSentence(Context context, IContinuation succ, IFailure fail, params object[] args)
        {
            int? sentenceStart = context.LookupDefaulted<int?>("$sentences.index", null);

            TwoTuple<List<IContent>, IContinuation> parts = SplitArguments(context, succ);
            List<IContent> chunk = parts.one;

            Context first = new Context(context, chunk);
            first.Map["$sentences.index"] = sentenceStart + 1;

            GroupPhrase groupPhrase = new GroupPhrase((IParsedPhrase) context.Lookup("$sentences.check"));
            Matcher.MatchAgainst(salience, first, groupPhrase.GetBranch(sentenceStart.Value), new List<IParsedPhrase>(), parts.two, fail);
        }

        public override IParsedPhrase ConceptToPhrase(Context context, Concept concept, POSTagger tagger, GrammarParser parser)
        {
            Verbs.Person person = Verbs.Person.ThirdSingle;

            object start = context.LookupDefaulted<object>("$check", null);
            if (start != null && start is Datum) {
                Datum noundat = KnowledgeUtilities.GetClosestDatum(memory, (Datum) start, Relations.Relation.Subject);
                person = nouns.GetPerson(noundat.Right.Name);
            }

            return Relations.ConjugateToPhrase(memory, conjugate, person, concept);
        }

 public static List<Concept> GetEventConcepts(Context env)
 {
     return env.LookupDefaulted<List<Concept>>("$concept$%event", new List<Concept>());
 }

 public static List<IParsedPhrase> GetEventClauses(Context env)
 {
     return env.LookupDefaulted<List<IParsedPhrase>>("$clause$%event", new List<IParsedPhrase>());
 }