diff -r 000000000000 -r 6474c204b198 content/xul/templates/src/nsTemplateRule.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/content/xul/templates/src/nsTemplateRule.h	Wed Dec 31 06:09:35 2014 +0100
@@ -0,0 +1,328 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef nsTemplateRule_h__
+#define nsTemplateRule_h__
+
+#include "nsCOMPtr.h"
+#include "nsIAtom.h"
+#include "nsIRDFDataSource.h"
+#include "nsIRDFResource.h"
+#include "nsIContent.h"
+#include "nsIDOMNode.h"
+#include "nsTArray.h"
+#include "nsString.h"
+#include "nsIXULTemplateRuleFilter.h"
+#include "nsCycleCollectionParticipant.h"
+
+class nsIXULTemplateQueryProcessor;
+class nsTemplateQuerySet;
+
+class nsTemplateCondition
+{
+public:
+    // relations that may be used in a rule. They may be negated with the
+    // negate flag. Less and Greater are used for numeric comparisons and
+    // Before and After are used for string comparisons. For Less, Greater,
+    // Before, After, Startswith, Endswith, and Contains, the source is
+    // conceptually on the left of the relation and the target is on the
+    // right. For example, if the relation is Contains, that means Match if
+    // the source contains the target.
+    enum ConditionRelation {
+        eUnknown,
+        eEquals,
+        eLess,
+        eGreater,
+        eBefore,
+        eAfter,
+        eStartswith,
+        eEndswith,
+        eContains
+    };
+
+    nsTemplateCondition(nsIAtom* aSourceVariable,
+                        const nsAString& aRelation,
+                        nsIAtom* aTargetVariable,
+                        bool mIgnoreCase,
+                        bool mNegate);
+
+    nsTemplateCondition(nsIAtom* aSourceVariable,
+                        const nsAString& aRelation,
+                        const nsAString& aTargets,
+                        bool mIgnoreCase,
+                        bool mNegate,
+                        bool aIsMultiple);
+
+    nsTemplateCondition(const nsAString& aSource,
+                        const nsAString& aRelation,
+                        nsIAtom* aTargetVariable,
+                        bool mIgnoreCase,
+                        bool mNegate);
+
+    ~nsTemplateCondition() { MOZ_COUNT_DTOR(nsTemplateCondition); }
+
+    nsTemplateCondition* GetNext() { return mNext; }
+    void SetNext(nsTemplateCondition* aNext) { mNext = aNext; }
+
+    void SetRelation(const nsAString& aRelation);
+
+    bool
+    CheckMatch(nsIXULTemplateResult* aResult);
+
+    bool
+    CheckMatchStrings(const nsAString& aLeftString,
+                      const nsAString& aRightString);
+protected:
+
+    nsCOMPtr<nsIAtom>   mSourceVariable;
+    nsString            mSource;
+    ConditionRelation   mRelation;
+    nsCOMPtr<nsIAtom>   mTargetVariable;
+    nsTArray<nsString>  mTargetList;
+    bool                mIgnoreCase;
+    bool                mNegate;
+
+   nsTemplateCondition* mNext;
+};
+
+/**
+ * A rule consists of:
+ *
+ * - Conditions, a set of unbound variables with consistency
+ *   constraints that specify the values that each variable can
+ *   assume. The conditions must be completely and consistently
+ *   "bound" for the rule to be considered "matched".
+ *
+ * - Bindings, a set of unbound variables with consistency constraints
+ *   that specify the values that each variable can assume. Unlike the
+ *   conditions, the bindings need not be bound for the rule to be
+ *   considered matched.
+ *
+ * - Content that should be constructed when the rule is "activated".
+ *
+ */
+class nsTemplateRule
+{
+public:
+    nsTemplateRule(nsIContent* aRuleNode,
+                   nsIContent* aAction,
+                   nsTemplateQuerySet* aQuerySet);
+    /**
+     * The copy-constructor should only be called from nsTArray when appending
+     * a new rule, otherwise things break because the copy constructor expects
+     * mBindings and mConditions to be nullptr.
+     */
+    nsTemplateRule(const nsTemplateRule& aOtherRule);
+
+    ~nsTemplateRule();
+
+    /**
+     * Return the <action> node that this rule was constructed from, or its
+     * logical equivalent for shorthand syntaxes. That is, the parent node of
+     * the content that should be generated for this rule.
+     */
+    nsIContent* GetAction() const { return mAction; }
+
+    /**
+     * Return the <rule> content node that this rule was constructed from.
+     * @param aResult an out parameter, which will contain the rule node
+     * @return NS_OK if no errors occur.
+     */
+    nsresult GetRuleNode(nsIDOMNode** aResult) const;
+
+    void SetVars(nsIAtom* aRefVariable, nsIAtom* aMemberVariable)
+    {
+        mRefVariable = aRefVariable;
+        mMemberVariable = aMemberVariable;
+    }
+
+    void SetRuleFilter(nsIXULTemplateRuleFilter* aRuleFilter)
+    {
+        mRuleFilter = aRuleFilter;
+    }
+
+    nsIAtom* GetTag() { return mTag; }
+    void SetTag(nsIAtom* aTag) { mTag = aTag; }
+
+    nsIAtom* GetMemberVariable() { return mMemberVariable; }
+
+    /**
+     * Set the first condition for the rule. Other conditions are linked
+     * to it using the condition's SetNext method.
+     */
+    void SetCondition(nsTemplateCondition* aConditions);
+
+    /**
+     * Check if the result matches the rule by first looking at the conditions.
+     * If the results is accepted by the conditions, the rule filter, if any
+     * was set, is checked. If either check rejects a result, a match cannot
+     * occur for this rule and result.
+     */
+    bool
+    CheckMatch(nsIXULTemplateResult* aResult) const;
+
+    /**
+     * Determine if the rule has the specified binding
+     */
+    bool
+    HasBinding(nsIAtom* aSourceVariable,
+               nsAString& aExpr,
+               nsIAtom* aTargetVariable) const;
+
+    /**
+     * Add a binding to the rule. A binding consists of an already-bound
+     * source variable, and the RDF property that should be tested to
+     * generate a target value. The target value is bound to a target
+     * variable.
+     *
+     * @param aSourceVariable the source variable that will be used in
+     *   the RDF query.
+     * @param aExpr the expression that will be used in the query.
+     * @param aTargetVariable the variable whose value will be bound
+     *   to the RDF node that is returned when querying the binding
+     * @return NS_OK if no errors occur.
+     */
+    nsresult AddBinding(nsIAtom* aSourceVariable,
+                        nsAString& aExpr,
+                        nsIAtom* aTargetVariable);
+
+    /**
+     * Inform the query processor of the bindings that are set for a rule.
+     * This should be called after all the bindings for a rule are compiled.
+     */
+    nsresult
+    AddBindingsToQueryProcessor(nsIXULTemplateQueryProcessor* aProcessor);
+
+    void Traverse(nsCycleCollectionTraversalCallback &cb) const
+    {
+        cb.NoteXPCOMChild(mRuleNode);
+        cb.NoteXPCOMChild(mAction);
+    }
+
+protected:
+
+    struct Binding {
+        nsCOMPtr<nsIAtom>        mSourceVariable;
+        nsCOMPtr<nsIAtom>        mTargetVariable;
+        nsString                 mExpr;
+        Binding*                 mNext;
+        Binding*                 mParent;
+    };
+
+    // backreference to the query set which owns this rule
+    nsTemplateQuerySet* mQuerySet;
+
+    // the <rule> node, or the <template> node if there is no <rule>
+    nsCOMPtr<nsIDOMNode> mRuleNode;
+
+    // the <action> node, or, if there is no <action>, the container node
+    // which contains the content to generate
+    nsCOMPtr<nsIContent> mAction;
+
+    // the rule filter set by the builder's SetRuleFilter function
+    nsCOMPtr<nsIXULTemplateRuleFilter> mRuleFilter;
+
+    // indicates that the rule will only match when generating content 
+    // to be inserted into a container with this tag
+    nsCOMPtr<nsIAtom> mTag;
+
+    // linked-list of the bindings for the rule, owned by the rule.
+    Binding* mBindings;
+
+    nsCOMPtr<nsIAtom> mRefVariable;
+    nsCOMPtr<nsIAtom> mMemberVariable;
+
+    nsTemplateCondition* mConditions; // owned by nsTemplateRule
+};
+
+/** nsTemplateQuerySet
+ *
+ *  A single <queryset> which holds the query node and the rules for it.
+ *  All builders have at least one queryset, which may be created with an
+ *  explicit <queryset> tag or implied if the tag is not used.
+ *
+ *  These queryset objects are created and owned by the builder in its
+ *  mQuerySets array.
+ */
+class nsTemplateQuerySet
+{
+protected:
+    nsTArray<nsTemplateRule> mRules;
+
+    // a number which increments for each successive queryset. It is stored so
+    // it can be used as an optimization when updating results so that it is
+    // known where to insert them into a match.
+    int32_t mPriority;
+
+public:
+
+    // <query> node
+    nsCOMPtr<nsIContent> mQueryNode;
+
+    // compiled opaque query object returned by the query processor's
+    // CompileQuery call
+    nsCOMPtr<nsISupports> mCompiledQuery;
+
+    // indicates that the query will only generate content to be inserted into
+    // a container with this tag
+    nsCOMPtr<nsIAtom> mTag;
+
+    nsTemplateQuerySet(int32_t aPriority)
+        : mPriority(aPriority)
+    {
+        MOZ_COUNT_CTOR(nsTemplateQuerySet);
+    }
+
+    ~nsTemplateQuerySet()
+    {
+        MOZ_COUNT_DTOR(nsTemplateQuerySet);
+    }
+
+    int32_t Priority() const
+    {
+        return mPriority;
+    }
+
+    nsIAtom* GetTag() { return mTag; }
+    void SetTag(nsIAtom* aTag) { mTag = aTag; }
+
+    nsTemplateRule* NewRule(nsIContent* aRuleNode,
+                            nsIContent* aAction,
+                            nsTemplateQuerySet* aQuerySet)
+    {
+        // nsTemplateMatch stores the index as a 16-bit value,
+        // so check to make sure for overflow
+        if (mRules.Length() == INT16_MAX)
+            return nullptr;
+
+        return mRules.AppendElement(nsTemplateRule(aRuleNode, aAction,
+                                    aQuerySet));
+    }
+    
+    void RemoveRule(nsTemplateRule *aRule)
+    {
+        mRules.RemoveElementAt(aRule - mRules.Elements());
+    }
+
+    int16_t RuleCount() const
+    {
+        return mRules.Length();
+    }
+
+    nsTemplateRule* GetRuleAt(int16_t aIndex)
+    {
+        if (uint32_t(aIndex) < mRules.Length()) {
+            return &mRules[aIndex];
+        }
+        return nullptr;
+    }
+
+    void Clear()
+    {
+        mRules.Clear();
+    }
+};
+
+#endif // nsTemplateRule_h__