Get the current indentation, computed as <code>indentLevel x indendtString</code>.

@return the indentation
558602
String getIndentation()
	{
		StringBuilder sb = new StringBuilder();

		for (int i = 0; i < count; i++)
		{
			sb.append(indent);
		}

		return sb.toString();
	}
612623
function(){
    var tok = this.expect('indent');
    var block = this.emptyBlock(tok.loc.start.line);
    while ('outdent' != this.peek().type) {
      if ('newline' == this.peek().type) {
        this.advance();
      } else if ('text-html' == this.peek().type) {
        block.nodes = block.nodes.concat(this.parseTextHtml());
      } else {
        var expr = this.parseExpr();
        if (expr.type === 'Block') {
          block.nodes = block.nodes.concat(expr.nodes);
        } else {
          block.nodes.push(expr);
        }
      }
    }
    this.expect('outdent');
    return block;
  }
431106
public Note getNoteFirstExtendedLineHigh() {
		if (m_highNote == null) {
			//A 7th (label=6) for 5 lines,
			//A 5th (label=4) for 3 lines,
			//A 3rd (label=2) for 1 line
			byte label = (byte) (getStaffLines() + 1);
			Interval interv = new Interval(label,
				label==5?Interval.PERFECT:Interval.MAJOR,
				Interval.UPWARD);
			m_highNote = interv.calculateSecondNote(getMiddleNote());
			m_highNote.setAccidental(new Accidental());//Accidental.NONE
		}
		return m_highNote;
	}
176532
public String getString() 
    {       // Usually overidden
        int maxLength = this.getMaxLength();
        String string = (String)this.getData();
        if (string == null)
            return Constants.BLANK;
        if (string.length() > maxLength)
            string = string.substring(0, maxLength);
        return string;
    }
1254780
public java.lang.String getTabindex() {
        return (java.lang.String) getStateHelper().eval(PropertyKeys.tabindex);

    }
837437
def determine_indentation(self):
        """"""
        # Ensuring NEWLINE tokens are actually specified as such
        if self.current.tokenum != NEWLINE and self.current.value == '\n':
            self.current.tokenum = NEWLINE

        # I want to change dedents into indents, because they seem to screw nesting up
        if self.current.tokenum == DEDENT:
            self.current.tokenum, self.current.value = self.convert_dedent()

        if self.after_space and not self.is_space and (not self.in_container or self.just_started_container):
            # Record current indentation level
            if not self.indent_amounts or self.current.scol > self.indent_amounts[-1]:
                self.indent_amounts.append(self.current.scol)

            # Adjust indent as necessary
            while self.adjust_indent_at:
                self.result[self.adjust_indent_at.pop()] = (INDENT, self.indent_type * (self.current.scol - self.groups.level))

        # Roll back groups as necessary
        if not self.is_space and not self.in_container:
            while not self.groups.root and self.groups.level >= self.current.scol:
                self.finish_hanging()
                self.groups = self.groups.parent

        # Reset indentation to deal with nesting
        if self.current.tokenum == INDENT and not self.groups.root:
           self.current.value = self.current.value[self.groups.level:]
595403
public function getLineIndentation()
    {
        $first = $this->getFirstTokenOnLine();
        if ( ! $first->matches(T_WHITESPACE)) {
            return '';
        }

        return $first->getContentUntil($first->findNextToken('NO_WHITESPACE')->get());
    }
1266948
public String getFormatted() {
        String input = this.getUnformatted() + "   ";
        StringBuilder buf = new StringBuilder();
        for (int i = 0; i < this.getUnformatted().length(); i+= 4) {
            buf.append(input, i, i+4);
            buf.append(' ');
        }
        return buf.toString().trim();
    }
787893
public Integer getIndent() {
		if (!"yes".equals(get(OutputKeys.INDENT))) {
			return null;
		}

		String value = get(INDENT_AMT);
		return (value == null) ? null : Integer.valueOf(value);
	}
964076
protected float indentLeft() {
        return left(indentation.indentLeft + indentation.listIndentLeft + indentation.imageIndentLeft + indentation.sectionIndentLeft);
    }
133767
public void indent() throws IOException {
        for (int i=0; i<indent; i++) writeRawString("   ");
    }

    /**
     * Method to increase the indent depth of the output writer.
     * @throws IOException Thrown if an error occurs during write.
     */
    public void indentPush()
    {
        indent++;
    }

    /**
     * Method to reduce the indent depth of the output writer.
     */
    public void indentPop()
    {
        indent--;
        if (indent < 0) throw new IllegalStateException();
    }

    /**
     * Method to get a list of all the property names stored in a map.
     */
    public List getPropertyNames(Map map)
    {
        List propertyNames = super.getPropertyNames(map);

        Collections.sort(propertyNames);

        return propertyNames;
    }

}
881114
public int getValueIndex() {

        int result = 0;
        Node previousSibling = getElement().getPreviousSibling();
        while (previousSibling != null) {
            result++;
            previousSibling = previousSibling.getPreviousSibling();
        }
        return result;
    }
909087
private static char[] getIndent(int indentSize, Map<Integer, char[]> indentCache) {
        char[] indent = indentCache.get(indentSize);
        if (indent == null) {
            indent = new char[indentSize];
            Arrays.fill(indent, SPACE);
            indentCache.put(indentSize, indent);
        }

        return indent;
    }
653662
protected String getIndent(int depth, int size) {
        final int length = depth * size;
        String indent = indentCache.get(length);
        if (indent == null) {
            indent = getLineSeparator() + StringUtils.repeat(" ", length);
            indentCache.put(length, indent);
        }
        return indent;
    }
196435
public String getParentXPath() {
        Iterator<Level> levelIterator = path.descendingIterator();
        if (levelIterator.hasNext()) {
            levelIterator.next();
        }
        return getXPath(levelIterator);
    }
820649
def get_line_indent(token):
    """"""
    start = token.start_mark.buffer.rfind('\n', 0,
                                          token.start_mark.pointer) + 1
    content = start
    while token.start_mark.buffer[content] == ' ':
        content += 1
    return content - start
447104
public function getIndent()
    {
        $leadingWhitespace = array();
        $n = 0;
        foreach( $this->lines as $line ) {
            if( !empty( $line ) ) {
                $leadingWhitespace[$n] = strlen( $line ) - strlen( ltrim( $line ) );
            }
            $n++;
        }
        return min( $leadingWhitespace );
    }