Returns the clipped path, which clips the ripple circle so that it doesn't goes beyond
the <b>Action Button</b> circle

@return clipped path, which clips the ripple circle
974045
private Path getCircleClipPath() {
		Path path = new Path();
		path.addCircle(getActionButton().calculateCenterX(), getActionButton().calculateCenterY(),
				getActionButton().calculateCircleRadius(), Path.Direction.CW);
		return path;
	}
109768
public PathElement getLastElement() {
        final List<PathElement> list = pathAddressList;
        return list.size() == 0 ? null : list.get(list.size() - 1);
    }
196435
public String getParentXPath() {
        Iterator<Level> levelIterator = path.descendingIterator();
        if (levelIterator.hasNext()) {
            levelIterator.next();
        }
        return getXPath(levelIterator);
    }
1278874
public String prettyPrintTargetPath() {
        StringBuilder result = new StringBuilder();

        boolean atHead = true;
        for (String pathToken : target) {

            String arrayAccessor = extractArrayAccessor(pathToken);

            if ( !atHead && arrayAccessor == null ) {
                result.append(".");
            }

            if (arrayAccessor == null) {
                result.append(pathToken);
            } else {
                result.append(arrayAccessor);
            }

            atHead = false;
        }

        return result.toString();
    }
1258909
public String getPath() {
    StringBuilder result = new StringBuilder().append('$');
    for (int i = 0, size = stackSize; i < size; i++) {
      switch (stack[i]) {
        case JsonScope.EMPTY_ARRAY:
        case JsonScope.NONEMPTY_ARRAY:
          result.append('[').append(pathIndices[i]).append(']');
          break;

        case JsonScope.EMPTY_OBJECT:
        case JsonScope.DANGLING_NAME:
        case JsonScope.NONEMPTY_OBJECT:
          result.append('.');
          if (pathNames[i] != null) {
            result.append(pathNames[i]);
          }
          break;

        case JsonScope.NONEMPTY_DOCUMENT:
        case JsonScope.EMPTY_DOCUMENT:
        case JsonScope.CLOSED:
          break;
      }
    }
    return result.toString();
  }
129249
public String getRequestPath() {
        StringBuilder builder;

        synchronized (tryLock) {
            builder = new StringBuilder(path.length() + 10);
            builder.append('/');
            if (!path.isEmpty()) {
                try {
                    builder.append(new URI(null, null, path, null).getRawPath());
                } catch (URISyntaxException e) {
                    throw new IllegalStateException();
                }
                if (tryDir) {
                    builder.append('/');
                }
            }
            if (encodedQuery != null) {
                builder.append('?');
                builder.append(encodedQuery);
            }
        }
        return builder.toString();
    }
1140066
public boolean previousPath() {
		// pre-decrement
		if (m_nextPathIndex == 0)
			return false;

		m_nextPathIndex--;
		m_currentSegmentIndex = -1;
		m_nextSegmentIndex = 0;
		m_segmentCount = _getSegmentCount(m_nextPathIndex);
		m_currentPathIndex = m_nextPathIndex;
		m_pathBegin = m_parent.getPathStart(m_currentPathIndex);
		resetToLastSegment();
		return true;
	}
202401
public String getPath() {
    // FIXME: This is sloppy/icky
    if (isRoot()) {
      return ROOT;
    }
    if (getParent().isRoot()) {
      return String.format("%s%s", ROOT, getName());
    }
    return String.format("%s%s%s", getParent().getPath(), SEPARATOR, getName());
  }
338222
public function getCatTreePath()
    {
        if ($this->_sCatTreePath === null) {
            $this->_sCatTreePath = false;
            if (($oManufacturerTree = $this->getManufacturerTree())) {
                $this->_sCatTreePath = $oManufacturerTree->getPath();
            }
        }

        return $this->_sCatTreePath;
    }
116268
private String getShortPath(String rootPath) {
        File file = new File(rootPath);
        String lastPathAfterSeparator = null;
        String shortPath = getWindowsShortPath(file.getAbsolutePath());
        if (StringUtils.isNotEmpty(shortPath)) {
            return getWindowsShortPath(file.getAbsolutePath());
        } else {
            while (StringUtils.isEmpty(getWindowsShortPath(file.getAbsolutePath()))) {
                String filePath = file.getAbsolutePath();
                if (StringUtils.isNotEmpty(lastPathAfterSeparator)) {
                    lastPathAfterSeparator = file.getAbsolutePath().substring(filePath.lastIndexOf(WINDOWS_SEPARATOR), filePath.length()) + lastPathAfterSeparator;
                } else {
                    lastPathAfterSeparator = file.getAbsolutePath().substring(filePath.lastIndexOf(WINDOWS_SEPARATOR), filePath.length());
                }
                file = file.getParentFile();
            }
            return getWindowsShortPath(file.getAbsolutePath()) + lastPathAfterSeparator;
        }
    }
1256174
private Segment currentSegment() {
    Segment segment = segments.currentSegment();
    if (segment.isFull()) {
      segments.currentSegment().flush();
      segment = segments.nextSegment();
    }
    return segment;
  }
810072
@JsonIgnore
    public String getCuredBranchPath() {
        String trim = StringUtils.trim(branchPath);
        if ("/".equals(trim)) {
            return trim;
        } else {
            return StringUtils.stripEnd(trim, "/");
        }
    }
246852
public static String getContnet() {
        String result = "";
        Clipboard clipboard = Toolkit.getDefaultToolkit().getSystemClipboard();
        try {
            result = (String) clipboard.getData(DataFlavor.stringFlavor);
        } catch (Exception ex) {
            //noop
        }
        return result;
    }
537172
protected Node getMask() {
        double borderWidth = ripplerPane.getBorder() != null ? ripplerPane.getBorder().getInsets().getTop() : 0;
        Bounds bounds = control.getBoundsInParent();
        double width = control.getLayoutBounds().getWidth();
        double height = control.getLayoutBounds().getHeight();
        double diffMinX = Math.abs(control.getBoundsInLocal().getMinX() - control.getLayoutBounds().getMinX());
        double diffMinY = Math.abs(control.getBoundsInLocal().getMinY() - control.getLayoutBounds().getMinY());
        double diffMaxX = Math.abs(control.getBoundsInLocal().getMaxX() - control.getLayoutBounds().getMaxX());
        double diffMaxY = Math.abs(control.getBoundsInLocal().getMaxY() - control.getLayoutBounds().getMaxY());
        Node mask;
        switch (getMaskType()) {
            case RECT:
                mask = new Rectangle(bounds.getMinX() + diffMinX - snappedLeftInset(),
                    bounds.getMinY() + diffMinY - snappedTopInset(),
                    width - 2 * borderWidth,
                    height - 2 * borderWidth); // -0.1 to prevent resizing the anchor pane
                break;
            case CIRCLE:
                double radius = Math.min((width / 2) - 2 * borderWidth, (height / 2) - 2 * borderWidth);
                mask = new Circle((bounds.getMinX() + diffMinX + bounds.getMaxX() - diffMaxX) / 2 - snappedLeftInset(),
                    (bounds.getMinY() + diffMinY + bounds.getMaxY() - diffMaxY) / 2 - snappedTopInset(),
                    radius,
                    Color.BLUE);
                break;
            case FIT:
                mask = new Region();
                if(control instanceof Shape){
                    ((Region) mask).setShape((Shape) control);
                }else if(control instanceof Region){
                    ((Region) mask).setShape(((Region) control).getShape());
                    JFXNodeUtils.updateBackground(((Region) control).getBackground(), (Region) mask);
                }
                mask.resize(width, height);
                mask.relocate(bounds.getMinX() + diffMinX, bounds.getMinY() + diffMinY);
                break;
            default:
                mask = new Rectangle(bounds.getMinX() + diffMinX - snappedLeftInset(),
                    bounds.getMinY() + diffMinY - snappedTopInset(),
                    width - 2 * borderWidth,
                    height - 2 * borderWidth); // -0.1 to prevent resizing the anchor pane
                break;
        }
        return mask;
    }
879816
@Nullable
  B getParent() {
    ImmutableList<String> parts = getSegments();
    if (parts.isEmpty()) {
      return null;
    }
    return createPathWithSegments(parts.subList(0, parts.size() - 1));
  }
664534
public FaunusPipeline simplePath() {
        this.state.assertNotLocked();
        this.state.assertNoProperty();

        this.compiler.addMap(CyclicPathFilterMap.Map.class,
                NullWritable.class,
                FaunusVertex.class,
                CyclicPathFilterMap.createConfiguration(this.state.getElementType()));
        makeMapReduceString(CyclicPathFilterMap.class);
        return this;
    }
1260346
private JComponent getEffectiveClippingAncestor() {
        JComponent clippingComponent = clippingAncestor;

        if ((clippingComponent == null) && (decoratedComponent != null)) {
            // No specific clipping ancestor specified by the programmer, so try to find one

            // Keep a reference to the best alternative candidate if no other proper ancestor can be found
            Container lastNonNullParent = decoratedComponent;

            // Look for the first viewport or layered pane in the component hierarchy tree
            Container parent = decoratedComponent.getParent();
            while ((parent != null) && (clippingComponent == null)) {
                lastNonNullParent = parent;
                if ((parent instanceof JViewport) || (parent instanceof JLayeredPane)) {
                    clippingComponent = (JComponent) parent;
                }
                parent = parent.getParent();
            }

            if (clippingComponent == null) {
                // This may be a normal case depending on the application logic to hide a panel (tabbed pane like)
                if (lastNonNullParent instanceof JComponent) {
                    clippingComponent = (JComponent) lastNonNullParent;
                }
            }
        }

        return clippingComponent;
    }