parser/html/javasrc/StateSnapshot.java

   1 /*
   2  * Copyright (c) 2009-2010 Mozilla Foundation
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a
   5  * copy of this software and associated documentation files (the "Software"),
   6  * to deal in the Software without restriction, including without limitation
   7  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   8  * and/or sell copies of the Software, and to permit persons to whom the
   9  * Software is furnished to do so, subject to the following conditions:
  10  *
  11  * The above copyright notice and this permission notice shall be included in
  12  * all copies or substantial portions of the Software.
  13  *
  14  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  15  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  16  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
  17  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  18  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  19  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  20  * DEALINGS IN THE SOFTWARE.
  21  */
  22
  23 package nu.validator.htmlparser.impl;
  24
  25 import nu.validator.htmlparser.annotation.Auto;
  26
  27
  28 public class StateSnapshot<T> implements TreeBuilderState<T> {
  29
  30     private final @Auto StackNode<T>[] stack;
  31
  32     private final @Auto StackNode<T>[] listOfActiveFormattingElements;
  33
  34     private final @Auto int[] templateModeStack;
  35
  36     private final T formPointer;
  37
  38     private final T headPointer;
  39
  40     private final int mode;
  41
  42     private final int originalMode;
  43
  44     private final boolean framesetOk;
  45
  46     private final boolean needToDropLF;
  47
  48     private final boolean quirks;
  49
  50     /**
  51      * @param stack
  52      * @param listOfActiveFormattingElements
  53      * @param templateModeStack
  54      * @param formPointer
  55      * @param headPointer
  56      * @param deepTreeSurrogateParent
  57      * @param mode
  58      * @param originalMode
  59      * @param framesetOk
  60      * @param needToDropLF
  61      * @param quirks
  62      */
  63     StateSnapshot(StackNode<T>[] stack,
  64             StackNode<T>[] listOfActiveFormattingElements, int[] templateModeStack, T formPointer,
  65             T headPointer, int mode, int originalMode,
  66             boolean framesetOk, boolean needToDropLF, boolean quirks) {
  67         this.stack = stack;
  68         this.listOfActiveFormattingElements = listOfActiveFormattingElements;
  69         this.templateModeStack = templateModeStack;
  70         this.formPointer = formPointer;
  71         this.headPointer = headPointer;
  72         this.mode = mode;
  73         this.originalMode = originalMode;
  74         this.framesetOk = framesetOk;
  75         this.needToDropLF = needToDropLF;
  76         this.quirks = quirks;
  77     }
  78
  79     /**
  80      * @see nu.validator.htmlparser.impl.TreeBuilderState#getStack()
  81      */
  82     @Override
  83     public StackNode<T>[] getStack() {
  84         return stack;
  85     }
  86
  87     /**
  88      * @see nu.validator.htmlparser.impl.TreeBuilderState#getTemplateModeStack()
  89      */
  90     @Override
  91     public int[] getTemplateModeStack() {
  92         return templateModeStack;
  93     }
  94
  95     /**
  96      * @see nu.validator.htmlparser.impl.TreeBuilderState#getListOfActiveFormattingElements()
  97      */
  98     @Override
  99     public StackNode<T>[] getListOfActiveFormattingElements() {
 100         return listOfActiveFormattingElements;
 101     }
 102
 103     /**
 104      * @see nu.validator.htmlparser.impl.TreeBuilderState#getFormPointer()
 105      */
 106     @Override
 107     public T getFormPointer() {
 108         return formPointer;
 109     }
 110
 111     /**
 112      * Returns the headPointer.
 113      *
 114      * @return the headPointer
 115      */
 116     @Override
 117     public T getHeadPointer() {
 118         return headPointer;
 119     }
 120
 121     /**
 122      * Returns the mode.
 123      *
 124      * @return the mode
 125      */
 126     @Override
 127     public int getMode() {
 128         return mode;
 129     }
 130
 131     /**
 132      * Returns the originalMode.
 133      *
 134      * @return the originalMode
 135      */
 136     @Override
 137     public int getOriginalMode() {
 138         return originalMode;
 139     }
 140
 141     /**
 142      * Returns the framesetOk.
 143      *
 144      * @return the framesetOk
 145      */
 146     @Override
 147     public boolean isFramesetOk() {
 148         return framesetOk;
 149     }
 150
 151     /**
 152      * Returns the needToDropLF.
 153      *
 154      * @return the needToDropLF
 155      */
 156     @Override
 157     public boolean isNeedToDropLF() {
 158         return needToDropLF;
 159     }
 160
 161     /**
 162      * Returns the quirks.
 163      *
 164      * @return the quirks
 165      */
 166     @Override
 167     public boolean isQuirks() {
 168         return quirks;
 169     }
 170
 171     /**
 172      * @see nu.validator.htmlparser.impl.TreeBuilderState#getListOfActiveFormattingElementsLength()
 173      */
 174     @Override
 175     public int getListOfActiveFormattingElementsLength() {
 176         return listOfActiveFormattingElements.length;
 177     }
 178
 179     /**
 180      * @see nu.validator.htmlparser.impl.TreeBuilderState#getStackLength()
 181      */
 182     @Override
 183     public int getStackLength() {
 184         return stack.length;
 185     }
 186
 187     /**
 188      * @see nu.validator.htmlparser.impl.TreeBuilderState#getTemplateModeStackLength()
 189      */
 190     @Override
 191     public int getTemplateModeStackLength() {
 192         return templateModeStack.length;
 193     }
 194
 195     @SuppressWarnings("unused") private void destructor() {
 196         for (int i = 0; i < stack.length; i++) {
 197             stack[i].release(null);
 198         }
 199         for (int i = 0; i < listOfActiveFormattingElements.length; i++) {
 200             if (listOfActiveFormattingElements[i] != null) {
 201                 listOfActiveFormattingElements[i].release(null);
 202             }
 203         }
 204     }
 205 }