textBlocks - Property. 
                        Returns all the blocks which are direct children of this node, where that block is a text (not a tag)

                @return list<AdvancedTag> - A list of direct children which are text.
321166
def textBlocks(self):
        '''
            
        '''
        myBlocks = self.blocks

        return [block for block in myBlocks if not issubclass(block.__class__, AdvancedTag)]
459340
public Set<TagModel> getDescendantTags(TagModel tag)
    {
        Set<TagModel> ancestors = new HashSet<>();
        getDescendantTags(tag, ancestors);
        return ancestors;
    }
637851
public Collection<BasicBlock> getBlocks(BitSet labelSet) {
        LinkedList<BasicBlock> result = new LinkedList<>();
        for (Iterator<BasicBlock> i = blockIterator(); i.hasNext();) {
            BasicBlock block = i.next();
            if (labelSet.get(block.getLabel())) {
                result.add(block);
            }
        }
        return result;
    }
1043510
function( node ) {
			var out = '',
				j = 0;

			if(node.tagName && this.excludeTags.indexOf( node.tagName.toLowerCase() ) > -1){
				return out;
			}

			// if node is a text node get its text
			if(node.nodeType && node.nodeType === 3){
				out += modules.domUtils.getElementText( node );
			}

			// get the text of the child nodes
			if(node.childNodes && node.childNodes.length > 0){
				for (j = 0; j < node.childNodes.length; j++) {
					var text = this.walkTreeForText( node.childNodes[j] );
					if(text !== undefined){
						out += text;
					}
				}
			}

			// if it's a block level tag add an additional space at the end
			if(node.tagName && this.blockLevelTags.indexOf( node.tagName.toLowerCase() ) !== -1){
				out += ' ';
			}

			return (out === '')? undefined : out ;
		}
155095
def texts(element)
        texts = []
        child_nodes = element.child_nodes
        (0...child_nodes.length).each do |i|
          item = child_nodes.item(i)
          if item.node_type == Node.TEXT_NODE
            texts << item.get_data
          end
        end
        texts
      end
1368793
def initialize_html_tags
      @permitted_html_tags = {}
      tags = {
        # special tag used for elements with no parent, i.e. top level
        '#document-fragment' => { type: :block, ast_class: :root, allowed_children: %i[_block _inline] },

        # block level tags
        table: { type: :block, ast_class: :table, allowed_children: %i[caption thead tbody tfoot tr ]},
        tr: { type: :block, ast_class: :table_row, allowed_children: %i[th td] },
        th: { type: :block, ast_class: :table_cell, properties: { b: nil, jc: 'center' }, allowed_children: %i[_block _inline] },
        td: { type: :block, ast_class: :table_cell, allowed_children: %i[_block _inline] },
        div: { type: :block, ast_class: :paragraph, properties: { pStyle: 'Normal' }, allowed_children: :_inline },
        p: { type: :block, ast_class: :paragraph, properties: { pStyle: 'Paragraph' }, allowed_children: :_inline },
        caption: { type: :block, ast_class: :paragraph, properties: { pStyle: 'Caption' }, allowed_children: :_inline },
        h1: { type: :block, ast_class: :paragraph, properties: { pStyle: 'Heading1' }, allowed_children: :_inline },
        h2: { type: :block, ast_class: :paragraph, properties: { pStyle: 'Heading2' }, allowed_children: :_inline },
        h3: { type: :block, ast_class: :paragraph, properties: { pStyle: 'Heading3' }, allowed_children: :_inline },
        h4: { type: :block, ast_class: :paragraph, properties: { pStyle: 'Heading4' }, allowed_children: :_inline },
        h5: { type: :block, ast_class: :paragraph, properties: { pStyle: 'Heading5' }, allowed_children: :_inline },
        h6: { type: :block, ast_class: :paragraph, properties: { pStyle: 'Heading6' }, allowed_children: :_inline },
        ol: { type: :block, ast_class: :list, properties: { pStyle: 'ListNumber' }, allowed_children: %i[ol li] },
        ul: { type: :block, ast_class: :list, properties: { pStyle: 'ListBullet' }, allowed_children: %i[ul li] },
        li: { type: :block, ast_class: :list_paragraph },

        # inline style tags for tables
        thead: { type: :inline, ast_class: nil, properties: { tblHeader: nil }, allowed_children: :tr },
        tbody: { type: :inline, ast_class: nil, properties: {}, allowed_children: :tr },
        tfoot: { type: :inline, ast_class: nil, properties: {}, allowed_children: :tr },

        # inline style tags
        span: { type: :inline, ast_class: nil, properties: {} },
        strong: { type: :inline, ast_class: nil, properties: { b: nil } },
        b: { type: :inline, ast_class: nil, properties: { b: nil } },
        em: { type: :inline, ast_class: nil, properties: { i: nil } },
        i: { type: :inline, ast_class: nil, properties: { i: nil } },
        u: { type: :inline, ast_class: nil, properties: { u: 'single' } },
        s: { type: :inline, ast_class: nil, properties: { strike: 'true' } },
        sub: { type: :inline, ast_class: nil, properties: { vertAlign: 'subscript' } },
        sup: { type: :inline, ast_class: nil, properties: { vertAlign: 'superscript' } },

        # inline content tags
        a: { type: :inline, ast_class: :hyperlink, properties: { rStyle: 'Hyperlink' } },
        text: { type: :inline, ast_class: :run, properties: {}, allowed_children: [] },
        br: { type: :inline, ast_class: :newline, properties: {}, allowed_children: [] }
      }
      # add all tags to the config object
      tags.each do |tag_name, settings|
        type = settings.delete(:type)
        register_html_tag(tag_name, type, **settings)
      end
    end
1144184
public String toText() {
        StringBuilder sb = new StringBuilder();
        if (!description.isEmpty()) {
            sb.append(description.toText());
            sb.append(EOL);
        }
        if (!blockTags.isEmpty()) {
            sb.append(EOL);
        }
        for (JavadocBlockTag tag : blockTags) {
            sb.append(tag.toText()).append(EOL);
        }
        return sb.toString();
    }
865042
public Content getMemberTree(Content contentTree) {
        Content ul = HtmlTree.UL(HtmlStyle.blockList, contentTree);
        return ul;
    }
227643
def parent_tags(self):
        """"""
        tags = set()

        for addr in self._addresses:
            if addr.attr == 'text':
                tags.add(addr.element.tag)
            tags.update(el.tag for el in addr.element.iterancestors())

        tags.discard(HTMLFragment._root_tag)
        return frozenset(tags)
1346035
public Set<Tag> getDescendantTags(Tag tag)
    {
        Set<Tag> ancestors = new HashSet<>();
        getDescendantTags(tag, ancestors);
        return ancestors;
    }
340900
public List<Node> childNodesCopy() {
        final List<Node> nodes = ensureChildNodes();
        final ArrayList<Node> children = new ArrayList<>(nodes.size());
        for (Node node : nodes) {
            children.add(node.clone());
        }
        return children;
    }
728918
public Collection<String> getAllTags() {
		return wrappedSubmit(new Callable<Collection<String>>() {

			@Override
			public Collection<String> call() throws Exception {
				Collection<String> allTags = new HashSet<String>();
				ObjectMapper mapper = new ObjectMapper();
				List<XmlTag> xmltags = new ArrayList<XmlTag>();
				try {xmltags = mapper.readValue(
										service.path(resourceTags)
										.accept(MediaType.APPLICATION_JSON)
										.get(String.class)	
									,new TypeReference<List<XmlTag>>(){});
				} catch (JsonParseException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				} catch (JsonMappingException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				} catch (ClientHandlerException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				for (XmlTag xmltag : xmltags) {
					allTags.add(xmltag.getName());
				}
				return allTags;
			}
		});
	}
741268
public List<Tag> getRootTags()
    {
        return this.definedTags.values().stream()
                    .filter(Tag::isRoot)
                    .collect(Collectors.toList());
    }
969363
public List<AstNode> getStatements() {
        List<AstNode> stmts = new ArrayList<AstNode>();
        Node n = getFirstChild();
        while (n != null) {
            stmts.add((AstNode)n);
            n = n.getNext();
        }
        return stmts;
    }
671619
public List<String> getTags() {
        return mBodyMap.containsKey(BoxItem.FIELD_TAGS) ?
                (List<String>) mBodyMap.get(BoxItem.FIELD_TAGS) :
                null;
    }
629205
protected Parse[] advanceTags(final Parse p) {
    final Parse[] children = p.getChildren();
    final String[] words = new String[children.length];
    final double[] probs = new double[words.length];
    for (int i = 0, il = children.length; i < il; i++) {
      words[i] = children[i].getCoveredText();
    }
    final Sequence[] ts = this.tagger.topKSequences(words);
    if (ts.length == 0) {
      System.err.println("no tag sequence");
    }
    final Parse[] newParses = new Parse[ts.length];
    for (int i = 0; i < ts.length; i++) {
      final String[] tags = ts[i].getOutcomes()
          .toArray(new String[words.length]);
      ts[i].getProbs(probs);
      newParses[i] = (Parse) p.clone(); // copies top level
      if (this.createDerivationString) {
        newParses[i].getDerivation().append(i).append(".");
      }
      for (int j = 0; j < words.length; j++) {
        final Parse word = children[j];
        // System.err.println("inserting tag "+tags[j]);
        final double prob = probs[j];
        newParses[i].insert(new Parse(word.getText(), word.getSpan(),
            tags[j].replaceAll("-" + BioCodec.START, ""), prob, j));
        newParses[i].addProb(Math.log(prob));
        // newParses[i].show();
      }
    }
    return newParses;
  }
137402
public List<TagType<TldTaglibType<T>>> getAllTag()
   {
      List<TagType<TldTaglibType<T>>> list = new ArrayList<TagType<TldTaglibType<T>>>();
      List<Node> nodeList = childNode.get("tag");
      for(Node node: nodeList)
      {
         TagType<TldTaglibType<T>>  type = new TagTypeImpl<TldTaglibType<T>>(this, "tag", childNode, node);
         list.add(type);
      }
      return list;
   }