The Tor Browser: comparison content/xul/templates/src/nsTemplateRule.h

--1:000000000000
+:9ac9ec32922d
+/* -*- 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__

The Tor Browser / file comparison

comparison: content/xul/templates/src/nsTemplateRule.h

content/xul/templates/src/nsTemplateRule.h