txStylesheet.h - mozsearch

Enable keyboard shortcuts

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */

/* 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 TX_TXSTYLESHEET_H

#define TX_TXSTYLESHEET_H

#include "txOutputFormat.h"

#include "txExpandedNameMap.h"

#include "txList.h"

#include "txXSLTPatterns.h"

#include "nsISupportsImpl.h"

class txInstruction;

class txTemplateItem;

class txVariableItem;

class txStripSpaceItem;

class txAttributeSetItem;

class txDecimalFormat;

class txStripSpaceTest;

class txXSLKey;

class txStylesheet final {

 public:

  class ImportFrame;

  class GlobalVariable;

  friend class txStylesheetCompilerState;

  // To be able to do some cleaning up in destructor

  friend class ImportFrame;

  txStylesheet();

  nsresult init();

  NS_INLINE_DECL_REFCOUNTING(txStylesheet)

  nsresult findTemplate(const txXPathNode& aNode, const txExpandedName& aMode,

                        txIMatchContext* aContext, ImportFrame* aImportedBy,

                        txInstruction** aTemplate, ImportFrame** aImportFrame);

  txDecimalFormat* getDecimalFormat(const txExpandedName& aName);

  txInstruction* getAttributeSet(const txExpandedName& aName);

  txInstruction* getNamedTemplate(const txExpandedName& aName);

  txOutputFormat* getOutputFormat();

  GlobalVariable* getGlobalVariable(const txExpandedName& aName);

  const txOwningExpandedNameMap<txXSLKey>& getKeyMap();

  nsresult isStripSpaceAllowed(const txXPathNode& aNode,

                               txIMatchContext* aContext, bool& aAllowed);

/**

   * Called by the stylesheet compiler once all stylesheets has been read.

*/

  nsresult doneCompiling();

/**

   * Add a key to the stylesheet

*/

  nsresult addKey(const txExpandedName& aName,

                  mozilla::UniquePtr<txPattern> aMatch,

                  mozilla::UniquePtr<Expr> aUse);

/**

   * Add a decimal-format to the stylesheet

*/

  nsresult addDecimalFormat(const txExpandedName& aName,

                            mozilla::UniquePtr<txDecimalFormat>&& aFormat);

  struct MatchableTemplate {

    txInstruction* mFirstInstruction;

    mozilla::UniquePtr<txPattern> mMatch;

    double mPriority;

};

/**

   * Contain information that is import precedence dependant.

*/

  class ImportFrame {

   public:

    ImportFrame() : mFirstNotImported(nullptr) {}

    ~ImportFrame();

    // List of toplevel items

    txList mToplevelItems;

    // Map of template modes

    txOwningExpandedNameMap<nsTArray<MatchableTemplate> > mMatchableTemplates;

    // ImportFrame which is the first one *not* imported by this frame

    ImportFrame* mFirstNotImported;

};

  class GlobalVariable : public txObject {

   public:

    GlobalVariable(mozilla::UniquePtr<Expr>&& aExpr,

                   mozilla::UniquePtr<txInstruction>&& aFirstInstruction,

                   bool aIsParam);

    mozilla::UniquePtr<Expr> mExpr;

    mozilla::UniquePtr<txInstruction> mFirstInstruction;

    bool mIsParam;

};

 private:

  // Private destructor, to discourage deletion outside of Release():

  ~txStylesheet();

  nsresult addTemplate(txTemplateItem* aTemplate, ImportFrame* aImportFrame);

  nsresult addGlobalVariable(txVariableItem* aVariable);

  nsresult addFrames(txListIterator& aInsertIter);

  nsresult addStripSpace(txStripSpaceItem* aStripSpaceItem,

                         nsTArray<txStripSpaceTest*>& aFrameStripSpaceTests);

  nsresult addAttributeSet(txAttributeSetItem* aAttributeSetItem);

  // List of ImportFrames

  txList mImportFrames;

  // output format

  txOutputFormat mOutputFormat;

  // List of first instructions of templates. This is the owner of all

  // instructions used in templates

  txList mTemplateInstructions;

  // Root importframe

  ImportFrame* mRootFrame;

  // Named templates

  txExpandedNameMap<txInstruction> mNamedTemplates;

  // Map with all decimal-formats

  txOwningExpandedNameMap<txDecimalFormat> mDecimalFormats;

  // Map with all named attribute sets

  txExpandedNameMap<txInstruction> mAttributeSets;

  // Map with all global variables and parameters

  txOwningExpandedNameMap<GlobalVariable> mGlobalVariables;

  // Map with all keys

  txOwningExpandedNameMap<txXSLKey> mKeys;

  // Array of all txStripSpaceTests, sorted in acending order

  nsTArray<mozilla::UniquePtr<txStripSpaceTest> > mStripSpaceTests;

  // Default templates

  mozilla::UniquePtr<txInstruction> mContainerTemplate;

  mozilla::UniquePtr<txInstruction> mCharactersTemplate;

  mozilla::UniquePtr<txInstruction> mEmptyTemplate;

};

/**

 * txStripSpaceTest holds both an txNameTest and a bool for use in

 * whitespace stripping.

*/

class txStripSpaceTest {

 public:

  txStripSpaceTest(nsAtom* aPrefix, nsAtom* aLocalName, int32_t aNSID,

                   bool stripSpace)

      : mNameTest(aPrefix, aLocalName, aNSID, txXPathNodeType::ELEMENT_NODE),

        mStrips(stripSpace) {}

  nsresult matches(const txXPathNode& aNode, txIMatchContext* aContext,

                   bool& aMatched) {

    return mNameTest.matches(aNode, aContext, aMatched);

  bool stripsSpace() { return mStrips; }

  double getDefaultPriority() { return mNameTest.getDefaultPriority(); }

 protected:

  txNameTest mNameTest;

  bool mStrips;

};

/**

 * Value of a global parameter

*/

class txIGlobalParameter {

 public:

  MOZ_COUNTED_DEFAULT_CTOR(txIGlobalParameter)

  MOZ_COUNTED_DTOR_VIRTUAL(txIGlobalParameter)

  virtual nsresult getValue(txAExprResult** aValue) = 0;

};

#endif  // TX_TXSTYLESHEET_H