Close the path.

@return path object, for compact syntax.
6700
public SVGPath close() {
    assert lastaction != 0 : "Paths must begin with a move to the initial position!";
    if(lastaction != PATH_CLOSE) {
      buf.append(' ').append(PATH_CLOSE);
      lastaction = PATH_CLOSE;
    }
    return this;
  }
862989
public function close(){
		switch($this->getMode()){
			case 'w':
			case 'wb':
			case 'a':
			case 'a+':
				$this->sync();
				$url = $this->getURI();
				return $this->call($url,array(
					 'action'	=>	self::FILE_IO_STORE
					,'path'		=>	$this->path
				));
				break;
			case 'r':
			case 'rb':
			default:
				return microtime(true);
				break;
		}
		return true;
	}
770691
def close_document(self, path):
        
        to_close = []
        for widget in self.widgets(include_clones=True):
            p = os.path.normpath(os.path.normcase(widget.file.path))
            path = os.path.normpath(os.path.normcase(path))
            if p == path:
                to_close.append(widget)
        for widget in to_close:
            tw = widget.parent_tab_widget
            tw.remove_tab(tw.indexOf(widget))
251330
void closePath(
      Graphics2D g, Path2D.Double path, double previousX, Rectangle2D bounds, double yTopMargin) {

    if (path != null) {
      double yBottomOfArea = getBounds().getY() + getBounds().getHeight() - yTopMargin;
      path.lineTo(previousX, yBottomOfArea);
      path.closePath();
      g.fill(path);
    }
  }
595880
@Override
	public void close() {
		Iterator<Map.Entry<Path, OpenCryptoFile>> iter = openCryptoFiles.entrySet().iterator();
		while (iter.hasNext()) {
			Map.Entry<Path, OpenCryptoFile> entry = iter.next();
			iter.remove(); // remove before invoking close() to avoid concurrent modification of this iterator by #close(OpenCryptoFile)
			entry.getValue().close();
		}
	}
902098
public function close()
    {
        if(isset($this->_link))
            $this->_link->close();

        if(isset($this->_sequencePool))
            $this->_sequencePool->close();

        return $this;
    }
633475
public function stream_close()
    {
        $this->stream_flush();
        fclose($this->fd);
        $this->path = null;
        $this->fd = null;
    }
351767
public function close() {
		$result = fclose($this->file);
		if($result == true) {
			$this->open = false;
			return true;
		}
		return false;
	}
1276827
public function getPath()
    {
        if (!$this->_path) {
            $this->_path = $this->detectPath($this->name);
        }

        return $this->_path;
    }
1022910
public String getLastPathSegment() {
        if (StringUtils.isBlank(path)) {
            return StringUtils.EMPTY;
        }
        String segment = path;
        segment = StringUtils.substringAfterLast(segment, "/");
        return segment;
    }
1029846
public function close()
    {
        $this->isOpen = false;
        $this->_programmingLanguage = str_replace(array('/', '\\', '..'), '', $this->_programmingLanguage);
        $currentContent = $this->_currentContent;
        $this->_currentContent = '';
        // remove the last carriage-return
        $last2 = substr($currentContent, -2);
        if ($last2 === "\r\n" || $last2 == "\n\r")
            $currentContent = substr($currentContent, 0, -2);
        else if (isset($last2[1]) && ($last2[1] == "\r" || $last2[1] == "\n"))
            $currentContent = substr($currentContent, 0, -1);
        // if no programming language was defined, it's a verbatim block
        if (empty($this->_programmingLanguage)) {
            return ('<pre>' . htmlspecialchars($currentContent) . '</pre>');
        }

        // is syntax highlighting disabled?
        if (!$this->engine->getConfig()->getParam('codeSyntaxHighlight') || !class_exists('\GeSHi'))
            return ('<pre><code class="language-' . $this->_programmingLanguage . '">' . htmlspecialchars($currentContent) . '</code></pre>');
        // syntax highlighting
        //if (!isset(self::$_geshi)) {
        self::$_geshi = new GeSHi('', '');
        //}
        self::$_geshi->set_source($currentContent);
        self::$_geshi->set_language($this->_programmingLanguage, true);
        self::$_geshi->enable_classes($this->engine->getConfig()->getParam('codeInlineStyles') ? false : true);
        //self::$_geshi->enable_line_numbers($this->engine->getConfig()->getParam('codeLineNumbers') ? GESHI_NORMAL_LINE_NUMBERS : GESHI_NO_LINE_NUMBERS);
        $result = self::$_geshi->parse_code();

        $start = '<pre class="' . $this->_programmingLanguage . '"';
        if (substr($result, 0, strlen($start)) == $start)
            $result = '<pre class="' . $this->_programmingLanguage . ' language-' . $this->_programmingLanguage . '"' . substr($result, strlen($start));

        $result .= '<style type="text/css">' . self::$_geshi->get_stylesheet(true) . '</style>';
        return ($result);
    }
567631
protected function getPathFromContent()
    {
        $pathFromContent = str_replace($this->getPathToContent(), '', $this->getFile()->getRealPath());

        return trim($pathFromContent, DIRECTORY_SEPARATOR);
    }
974114
public function unlink()
    {
        if($path = $this->getPath())
        {
            if(@unlink($path) === true)
            {
                if($this->getResource()) {
                    $this->close();
                }

                $this->_path = null;
                return true;
            }
        }
        else throw new BadMethodCallException('The stream "'.self::getName().'" does not support unlink.');

        return false;
    }
67179
public static function path()
    {
        if (!self::isDebug()) {
            return false;
        }

        $result = array(
            'get_include_path' => explode(PATH_SEPARATOR, trim(get_include_path(), PATH_SEPARATOR)),
            '$_SERVER[PATH]'   => explode(PATH_SEPARATOR, trim($_SERVER['PATH'], PATH_SEPARATOR))
        );

        return self::i()->dump($result, '! paths !');
    }
1180393
protected function _close() {
        if ($this->isConnected()) {
            fclose($this->_varnishConn);
            $this->_varnishConn = null;
        }
        return $this;
    }
68323
public function path(){

        $args = \func_get_args();

        switch (\count($args)){

            case 1:

                $file  = $args[0];

                if ($this->isAbsolutePath($file) && \file_exists($file)) {
                    return $file;
                }

                $parts = \explode(':', $file, 2);

                if (count($parts)==2){
                    if (!isset($this->paths[$parts[0]])) return false;

                    foreach ($this->paths[$parts[0]] as &$path){
                        if (\file_exists($path.$parts[1])){
                            return $path.$parts[1];
                        }
                    }
                }

                return false;

            case 2:

                if (!isset($this->paths[$args[0]])) {
                    $this->paths[$args[0]] = [];
                }
                \array_unshift($this->paths[$args[0]], \rtrim(\str_replace(DIRECTORY_SEPARATOR, '/', $args[1]), '/').'/');

                return $this;
        }

        return null;
    }
673522
function close()
    {
        if ($this->_opened) {
            mcal_close($this->_stream);
            $this->_opened = false;
        }

        return ($this->_opened === false);
    }