Returns a list of all statements contained within the document.

@return List of statements, which may be empty
491920
public List<Statement> getAllStatements() {
        final List<Statement> ret = new LinkedList<Statement>();
        for (final StatementGroup sg : statementGroups) {
            ret.addAll(sg.getAllStatements());
        }
        return ret;
    }
136497
public List<Mentsu> getAllMentsu() {
        List<Mentsu> allMentsu = new ArrayList<>(7);
        allMentsu.addAll(getToitsuList());
        allMentsu.addAll(getShuntsuList());
        allMentsu.addAll(getKotsuList());
        allMentsu.addAll(getKantsuList());

        return allMentsu;
    }
947985
public String list()
   {
      StringBuilder sb = new StringBuilder();

      Context c = null;
      try
      {
         c = new InitialContext();
         Context context = (Context)c.lookup("java:");
         sb.append("java:").append(NEW_LINE);
         list(context, " ", sb);
      }
      catch (Throwable t)
      {
         log.debug(t.getMessage(), t);
      }
      finally
      {
         if (c != null)
         {
            try
            {
               c.close();
            }
            catch (Throwable ignore)
            {
               // Ignore
            }
         }
      }

      return sb.toString();
   }
876210
public List<List<Word>> getSimpleSentenceList()
    {
        List<List<Word>> simpleList = new LinkedList<List<Word>>();
        for (Sentence sentence : sentenceList)
        {
            List<Word> wordList = new LinkedList<Word>();
            for (IWord word : sentence.wordList)
            {
                if (word instanceof CompoundWord)
                {
                    for (Word inner : ((CompoundWord) word).innerList)
                    {
                        wordList.add(inner);
                    }
                }
                else
                {
                    wordList.add((Word) word);
                }
            }
            simpleList.add(wordList);
        }

        return simpleList;
    }
919533
public List<Permutation> all() {
        final List<Permutation> permutations = new ArrayList<Permutation>();
        Backtracker counter = new Backtracker() {

            @Override
            public void applyTo(Permutation p) {
                permutations.add(p);
            }

            @Override
            public boolean isFinished() {
                return false;
            }
        };
        this.apply(counter);
        return permutations;
    }
422089
private function innerIfInnerStatementList() {
    static $terminators = [T_ELSEIF, T_ELSE, T_ENDIF];
    $node = new StatementBlockNode();
    while ($this->currentType !== NULL && !in_array($this->currentType, $terminators)) {
      $this->matchHidden($node);
      $node->addChild($this->innerStatement());
    }
    return $node;
  }
535899
@Override
	public List<CPInstance> findAll() {
		return findAll(QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
	}
147769
public java.util.List<DocumentIdentifier> getDocumentIdentifiers() {
        if (documentIdentifiers == null) {
            documentIdentifiers = new com.amazonaws.internal.SdkInternalList<DocumentIdentifier>();
        }
        return documentIdentifiers;
    }
769940
@SuppressWarnings("unchecked")
    public Map<String, Declaration> getDeclarations() {
        if ( this.dirty || (this.declarations == null) ) {
            this.declarations = this.getExtendedLhs( this, null ).getOuterDeclarations();
            this.dirty = false;
        }
        return this.declarations;
    }
983343
public List<StatementGroup> getAllStatementGroups() {
        final List<StatementGroup> ret = new ArrayList<StatementGroup>();
        ret.addAll(statementGroups);
        for (final StatementGroup sg : statementGroups) {
            ret.addAll(sg.getAllStatementGroups());
        }
        return ret;
    }
826782
protected final List<String> getExtraneousArguments() {
        if (commandLine == null) {
            return emptyList();
        }
        String[] args = commandLine.getArgs();
        if (noItems(args)) {
            return emptyList();
        }
        return asList(args);
    }
259227
public List<SyntacticCategory> getArgumentList() {
    if (isAtomic()) {
      return Lists.newArrayList();
    } else {
      List<SyntacticCategory> args = getReturn().getArgumentList();
      args.add(getArgument());
      return args;
    }
  }
157408
protected List<JCDiagnostic> getWhereClauses() {
        List<JCDiagnostic> clauses = List.nil();
        for (WhereClauseKind kind : WhereClauseKind.values()) {
            List<JCDiagnostic> lines = List.nil();
            for (Map.Entry<Type, JCDiagnostic> entry : whereClauses.get(kind).entrySet()) {
                lines = lines.prepend(entry.getValue());
            }
            if (!lines.isEmpty()) {
                String key = kind.key();
                if (lines.size() > 1)
                    key += ".1";
                JCDiagnostic d = diags.fragment(key, whereClauses.get(kind).keySet());
                d = new JCDiagnostic.MultilineDiagnostic(d, lines.reverse());
                clauses = clauses.prepend(d);
            }
        }
        return clauses.reverse();
    }
131581
@Override
    public List<EntityDeclaration> getEntities()
    {
        if (mEntities == null && (mSubset != null)) {
            /* Better make a copy, so that caller can not modify list
             * DTD has, which may be shared (since DTD subset instances
             * are cached and reused)
             */
            mEntities = new ArrayList<EntityDeclaration>(mSubset.getGeneralEntityList());
        }
        return mEntities;
    }
1324403
public java.util.List<DocumentVersionInfo> getDocumentVersions() {
        if (documentVersions == null) {
            documentVersions = new com.amazonaws.internal.SdkInternalList<DocumentVersionInfo>();
        }
        return documentVersions;
    }
12739
@SuppressWarnings("unchecked")
  public static List<Statement> getStatements(MethodNode method) {
    Statement code = method.getCode();
    if (!(code instanceof BlockStatement)) { // null or single statement
      BlockStatement block = new BlockStatement();
      if (code != null) block.addStatement(code);
      method.setCode(block);
    }
    return ((BlockStatement)method.getCode()).getStatements();
  }
238373
public int getTotalDocuments() {
    try {
      final int totalDocs = _jsonObject.getJSONObject(META_OBJECT_FIELD).getInt("total_count");
      return totalDocs;
    } catch (JSONException ex) {
      throw new QuandlRuntimeException("Could not find total_count field in results from Quandl", ex);
    }
  }