419:     path: &'a [u8],

1248: impl ToOwned for Path {

1308: pub struct Path {

1323: impl Path {

1780: impl AsRef<OsStr> for Path {

1786: impl fmt::Debug for Path {

1799:     path: &'a Path,

1814: impl cmp::PartialEq for Path {

1820: impl Hash for Path {

1828: impl cmp::Eq for Path {}

1830: impl cmp::PartialOrd for Path {

1836: impl cmp::Ord for Path {

1842: impl AsRef<Path> for Path {

1890: impl<'a> IntoIterator for &'a Path {

522:     pub fn as_path(&self) -> &'a Path {

653:     pub fn as_path(&self) -> &'a Path {

876:     pub fn as_path(&self) -> &Path {

1015:     pub fn into_boxed_path(self) -> Box<Path> {

848: pub struct PathBuf {

852: impl PathBuf {

1077: impl From<Box<Path>> for PathBuf {

1103: impl<T: ?Sized + AsRef<OsStr>> From<&T> for PathBuf {

1109: impl From<OsString> for PathBuf {

1127: impl From<String> for PathBuf {

1136: impl FromStr for PathBuf {

1144: impl<P: AsRef<Path>> iter::FromIterator<P> for PathBuf {

1152: impl<P: AsRef<Path>> iter::Extend<P> for PathBuf {

1158: impl fmt::Debug for PathBuf {

1164: impl ops::Deref for PathBuf {

1172: impl Borrow<Path> for PathBuf {

1178: impl Default for PathBuf {

1205: impl<'a> From<Cow<'a, Path>> for PathBuf {

1258: impl cmp::PartialEq for PathBuf {

1264: impl Hash for PathBuf {

1270: impl cmp::Eq for PathBuf {}

1272: impl cmp::PartialOrd for PathBuf {

1278: impl cmp::Ord for PathBuf {

1284: impl AsRef<OsStr> for PathBuf {

1878: impl AsRef<Path> for PathBuf {

1884: impl<'a> IntoIterator for &'a PathBuf {

1377:     pub fn to_path_buf(&self) -> PathBuf {

1773:     pub fn into_path_buf(self: Box<Path>) -> PathBuf {

29: //! Cross-platform path manipulation.

31: //! This module provides two types, [`PathBuf`] and [`Path`][`Path`] (akin to [`String`]

34: //! on strings according to the local platform's path syntax.

37: //! returned by the [`components`] method on [`Path`]. [`Component`]s roughly

38: //! correspond to the substrings between path separators (`/` or `\`). You can

39: //! reconstruct an equivalent path from components with the [`push`] method on

49: use crate::sys::path::{is_sep_byte, is_verbatim_sep, MAIN_SEP_STR, parse_prefix};

76: /// Windows path prefixes, e.g., `C:` or `\\server\share`.

78: /// Windows uses a variety of path prefix styles, including references to drive

80: /// others. In addition, some path prefixes are "verbatim" (i.e., prefixed with

182: /// Determines whether the character is one of the permitted path

189: /// The primary separator of path components for the current platform.

192: pub const MAIN_SEPARATOR: char = crate::sys::path::MAIN_SEP;

232:     let path = if let Some(p) = prefix {

237:     !path.is_empty() && is_sep_byte(path[0])

269: /// front and back of the path each keep track of what parts of the path have

272: /// Going front to back, a path is made up of a prefix, a starting

282: /// A structure wrapping a Windows path prefix as well as its unparsed string

346: /// A single component of a path.

348: /// A `Component` roughly corresponds to a substring between path separators

352: /// created by the [`components`][`Path::components`] method on [`Path`].

357:     /// A Windows path prefix, e.g., `C:` or `\\server\share`.

369:     /// It represents a separator that designates that a path starts from root.

394:             Component::Normal(path) => path,

405: impl AsRef<Path> for Component<'_> {

406:     fn as_ref(&self) -> &Path {

411: /// An iterator over the [`Component`]s of a [`Path`].

413: /// This `struct` is created by the [`components`] method on [`Path`].

418:     // The path left to parse components from

424:     // true if path *physically* has a root separator; for most Windows

435: /// An iterator over the [`Component`]s of a [`Path`], as [`OsStr`] slices.

437: /// This `struct` is created by the [`iter`] method on [`Path`].

441: /// [`iter`]: struct.Path.html#method.iter

443: /// [`Path`]: struct.Path.html

451:         struct DebugHelper<'a>(&'a Path);

462:             .field(&DebugHelper(self.as_path()))

489:     // Given the iteration so far, how much of the pre-State::Body path is left?

520:     /// Extracts a slice corresponding to the portion of the path remaining for iteration.

530:         unsafe { Path::from_u8_slice(comps.path) }

533:     /// Is the *original* path rooted?

546:     /// Should the normalized path include a leading . ?

551:         let mut iter = self.path[self.prefix_len()..].iter();

559:     // parse a given byte sequence into the corresponding path component

564:                           // the beginning of a path, which is treated

576:         let (extra, comp) = match self.path.iter().position(|b| self.is_sep_byte(*b)) {

577:             None => (0, self.path),

578:             Some(i) => (1, &self.path[..i]),

588:         let (extra, comp) = match self.path[start..].iter().rposition(|b| self.is_sep_byte(*b)) {

589:             None => (0, &self.path[start..]),

590:             Some(i) => (1, &self.path[start + i + 1..]),

597:         while !self.path.is_empty() {

602:                 self.path = &self.path[size..];

609:         while self.path.len() > self.len_before_body() {

614:                 self.path = &self.path[..self.path.len() - size];

620: impl AsRef<Path> for Components<'_> {

621:     fn as_ref(&self) -> &Path {

622:         self.as_path()

628:         self.as_path().as_os_str()

634:         struct DebugHelper<'a>(&'a Path);

645:             .field(&DebugHelper(self.as_path()))

651:     /// Extracts a slice corresponding to the portion of the path remaining for iteration.

654:         self.inner.as_path()

658: impl AsRef<Path> for Iter<'_> {

659:     fn as_ref(&self) -> &Path {

660:         self.as_path()

666:         self.as_path().as_os_str()

694:                     debug_assert!(self.prefix_len() <= self.path.len());

695:                     let raw = &self.path[..self.prefix_len()];

696:                     self.path = &self.path[self.prefix_len()..];

708:                         debug_assert!(!self.path.is_empty());

709:                         self.path = &self.path[1..];

716:                         debug_assert!(!self.path.is_empty());

717:                         self.path = &self.path[1..];

721:                 State::Body if !self.path.is_empty() => {

723:                     self.path = &self.path[size..];

742:                 State::Body if self.path.len() > self.len_before_body() => {

744:                     self.path = &self.path[..self.path.len() - size];

755:                         self.path = &self.path[..self.path.len() - 1];

762:                         self.path = &self.path[..self.path.len() - 1];

769:                         raw: unsafe { u8_slice_as_os_str(self.path) },

806: /// An iterator over [`Path`] and its ancestors.

808: /// This `struct` is created by the [`ancestors`] method on [`Path`].

813:     next: Option<&'a Path>,

817:     type Item = &'a Path;

821:         self.next = next.and_then(Path::parent);

832: /// An owned, mutable path (akin to [`String`]).

835: /// the path in place. It also implements [`Deref`] to [`Path`], meaning that

836: /// all methods on [`Path`] slices are available on `PathBuf` values as well.

839: /// [`Path`]: struct.Path.html

872:     /// Coerces to a [`Path`] slice.

874:     /// [`Path`]: struct.Path.html

880:     /// Extends `self` with `path`.

882:     /// If `path` is absolute, it replaces the current path.

886:     /// * if `path` has a root but no prefix (e.g., `\windows`), it

888:     /// * if `path` has a prefix but no root, it replaces `self`.

890:     pub fn push<P: AsRef<Path>>(&mut self, path: P) {

891:         self._push(path.as_ref())

894:     fn _push(&mut self, path: &Path) {

901:             if comps.prefix_len() > 0 && comps.prefix_len() == comps.path.len() &&

907:         // absolute `path` replaces `self`

908:         if path.is_absolute() || path.prefix().is_some() {

911:         // `path` has a root but no prefix, e.g., `\windows` (Windows only)

912:         } else if path.has_root() {

916:         // `path` is a pure relative path

921:         self.inner.push(path);

949:     /// `file_name`. The new path will be a sibling of the original path.

1011:     /// Converts this `PathBuf` into a [boxed][`Box`] [`Path`].

1014:     /// [`Path`]: struct.Path.html

1016:         let rw = Box::into_raw(self.inner.into_boxed_os_str()) as *mut Path;

1069: impl From<&Path> for Box<Path> {

1070:     fn from(path: &Path) -> Box<Path> {

1071:         let boxed: Box<OsStr> = path.inner.into();

1072:         let rw = Box::into_raw(boxed) as *mut Path;

1078:     /// Converts a `Box<Path>` into a `PathBuf`

1081:     fn from(boxed: Box<Path>) -> PathBuf {

1082:         boxed.into_path_buf()

1086: impl From<PathBuf> for Box<Path> {

1087:     /// Converts a `PathBuf` into a `Box<Path>`

1091:     fn from(p: PathBuf) -> Box<Path> {

1092:         p.into_boxed_path()

1096: impl Clone for Box<Path> {

1099:         self.to_path_buf().into_boxed_path()

1122:     fn from(path_buf : PathBuf) -> OsString {

1123:         path_buf.inner

1165:     type Target = Path;

1167:     fn deref(&self) -> &Path {

1168:         Path::new(&self.inner)

1173:     fn borrow(&self) -> &Path {

1184: impl<'a> From<&'a Path> for Cow<'a, Path> {

1186:     fn from(s: &'a Path) -> Cow<'a, Path> {

1191: impl<'a> From<PathBuf> for Cow<'a, Path> {

1193:     fn from(s: PathBuf) -> Cow<'a, Path> {

1198: impl<'a> From<&'a PathBuf> for Cow<'a, Path> {

1200:     fn from(p: &'a PathBuf) -> Cow<'a, Path> {

1201:         Cow::Borrowed(p.as_path())

1207:     fn from(p: Cow<'a, Path>) -> Self {

1212: impl From<PathBuf> for Arc<Path> {

1213:     /// Converts a Path into a Rc by copying the Path data into a new Rc buffer.

1215:     fn from(s: PathBuf) -> Arc<Path> {

1217:         unsafe { Arc::from_raw(Arc::into_raw(arc) as *const Path) }

1221: impl From<&Path> for Arc<Path> {

1222:     /// Converts a Path into a Rc by copying the Path data into a new Rc buffer.

1224:     fn from(s: &Path) -> Arc<Path> {

1226:         unsafe { Arc::from_raw(Arc::into_raw(arc) as *const Path) }

1230: impl From<PathBuf> for Rc<Path> {

1231:     /// Converts a Path into a Rc by copying the Path data into a new Rc buffer.

1233:     fn from(s: PathBuf) -> Rc<Path> {

1235:         unsafe { Rc::from_raw(Rc::into_raw(rc) as *const Path) }

1239: impl From<&Path> for Rc<Path> {

1240:     /// Converts a Path into a Rc by copying the Path data into a new Rc buffer.

1242:     fn from(s: &Path) -> Rc<Path> {

1244:         unsafe { Rc::from_raw(Rc::into_raw(rc) as *const Path) }

1251:         self.to_path_buf()

1266:         self.as_path().hash(h)

1290: /// A slice of a path (akin to [`str`]).

1292: /// This type supports a number of operations for inspecting a path, including

1293: /// breaking the path into its components (separated by `/` on Unix and by either

1294: /// `/` or `\` on Windows), extracting the file name, determining whether the path

1312: /// An error returned from [`Path::strip_prefix`][`strip_prefix`] if the prefix

1315: /// This `struct` is created by the [`strip_prefix`] method on [`Path`].

1318: /// [`strip_prefix`]: struct.Path.html#method.strip_prefix

1319: /// [`Path`]: struct.Path.html

1324:     // The following (private!) function allows construction of a path from a u8

1326:     unsafe fn from_u8_slice(s: &[u8]) -> &Path {

1327:         Path::new(u8_slice_as_os_str(s))

1334:     /// Directly wraps a string slice as a `Path` slice.

1338:     pub fn new<S: AsRef<OsStr> + ?Sized>(s: &S) -> &Path {

1339:         unsafe { &*(s.as_ref() as *const OsStr as *const Path) }

1350:     /// Yields a [`&str`] slice if the `Path` is valid unicode.

1360:     /// Converts a `Path` to a [`Cow<str>`].

1372:     /// Converts a `Path` to an owned [`PathBuf`].

1381:     /// Returns `true` if the `Path` is absolute, i.e., if it is independent of

1384:     /// * On Unix, a path is absolute if it starts with the root, so

1387:     /// * On Windows, a path is absolute if it has a prefix and starts with the

1395:     /// Returns `true` if the `Path` is relative, i.e., not absolute.

1407:     /// Returns `true` if the `Path` has a root.

1409:     /// * On Unix, a path has a root if it begins with `/`.

1411:     /// * On Windows, a path has a root if it:

1420:     /// Returns the `Path` without its final component, if there is one.

1422:     /// Returns [`None`] if the path terminates in a root or prefix.

1426:     pub fn parent(&self) -> Option<&Path> {

1433:                 Component::ParentDir => Some(comps.as_path()),

1439:     /// Produces an iterator over `Path` and its ancestors.

1441:     /// The iterator will yield the `Path` that is returned if the [`parent`] method is used zero

1453:     /// Returns the final component of the `Path`, if there is one.

1455:     /// If the path is a normal file, this is the file name. If it's the path of a directory, this

1458:     /// Returns [`None`] if the path terminates in `..`.

1471:     /// Returns a path that, when joined onto `base`, yields `self`.

1482:                            -> Result<&Path, StripPrefixError>

1483:         where P: AsRef<Path>

1488:     fn _strip_prefix(&self, base: &Path)

1489:                      -> Result<&Path, StripPrefixError> {

1491:             .map(|c| c.as_path())

1497:     /// Only considers whole path components to match.

1499:     pub fn starts_with<P: AsRef<Path>>(&self, base: P) -> bool {

1503:     fn _starts_with(&self, base: &Path) -> bool {

1509:     /// Only considers whole path components to match.

1511:     pub fn ends_with<P: AsRef<Path>>(&self, child: P) -> bool {

1515:     fn _ends_with(&self, child: &Path) -> bool {

1521:     /// [`self.file_name`]: struct.Path.html#method.file_name

1545:     /// [`self.file_name`]: struct.Path.html#method.file_name

1552:     /// Creates an owned [`PathBuf`] with `path` adjoined to `self`.

1554:     /// See [`PathBuf::push`] for more details on what it means to adjoin a path.

1559:     pub fn join<P: AsRef<Path>>(&self, path: P) -> PathBuf {

1560:         self._join(path.as_ref())

1563:     fn _join(&self, path: &Path) -> PathBuf {

1564:         let mut buf = self.to_path_buf();

1565:         buf.push(path);

1581:         let mut buf = self.to_path_buf();

1598:         let mut buf = self.to_path_buf();

1603:     /// Produces an iterator over the [`Component`]s of the path.

1605:     /// When parsing the path, there is a small amount of normalization:

1611:     ///   beginning of the path. For example, `a/./b`, `a/b/`, `a/b/.` and

1624:             path: self.as_u8_slice(),

1632:     /// Produces an iterator over the path's components viewed as [`OsStr`]

1635:     /// For more information about the particulars of how the path is separated

1651:         Display { path: self }

1679:     /// Returns the canonical, absolute form of the path with all intermediate

1716:     /// use std::path::Path;

1718:     /// let path = Path::new("/laputa");

1719:     /// for entry in path.read_dir().expect("read_dir call failed") {

1721:     ///         println!("{:?}", entry.path());

1729:     /// Returns whether the path points at an existing entity.

1742:     /// Returns `true` if the path exists on disk and is pointing at a regular file.

1755:     /// Returns `true` if the path exists on disk and is pointing at a directory.

1768:     /// Converts a [`Box<Path>`][`Box`] into a [`PathBuf`] without copying or

1794: /// A [`Path`] might contain non-Unicode data. This `struct` implements the

1796: /// [`display`][`Path::display`] method on [`Path`].

1804:         fmt::Debug::fmt(&self.path, f)

1810:         self.path.inner.display(f)

1815:     fn eq(&self, other: &Path) -> bool {

1831:     fn partial_cmp(&self, other: &Path) -> Option<cmp::Ordering> {

1837:     fn cmp(&self, other: &Path) -> cmp::Ordering {

1843:     fn as_ref(&self) -> &Path {

1848: impl AsRef<Path> for OsStr {

1849:     fn as_ref(&self) -> &Path {

1850:         Path::new(self)

1854: impl AsRef<Path> for Cow<'_, OsStr> {

1855:     fn as_ref(&self) -> &Path {

1856:         Path::new(self)

1860: impl AsRef<Path> for OsString {

1861:     fn as_ref(&self) -> &Path {

1862:         Path::new(self)

1866: impl AsRef<Path> for str {

1867:     fn as_ref(&self) -> &Path {

1868:         Path::new(self)

1872: impl AsRef<Path> for String {

1873:     fn as_ref(&self) -> &Path {

1874:         Path::new(self)

1879:     fn as_ref(&self) -> &Path {

1900:             fn eq(&self, other: &$rhs) -> bool { <Path as PartialEq>::eq(self, other) }

1905:             fn eq(&self, other: &$lhs) -> bool { <Path as PartialEq>::eq(self, other) }

1911:                 <Path as PartialOrd>::partial_cmp(self, other)

1918:                 <Path as PartialOrd>::partial_cmp(self, other)

1924: impl_cmp!(PathBuf, Path);

1925: impl_cmp!(PathBuf, &'a Path);

1926: impl_cmp!(Cow<'a, Path>, Path);

1927: impl_cmp!(Cow<'a, Path>, &'b Path);

1928: impl_cmp!(Cow<'a, Path>, PathBuf);

1934:             fn eq(&self, other: &$rhs) -> bool { <Path as PartialEq>::eq(self, other.as_ref()) }

1939:             fn eq(&self, other: &$lhs) -> bool { <Path as PartialEq>::eq(self.as_ref(), other) }

1945:                 <Path as PartialOrd>::partial_cmp(self, other.as_ref())

1952:                 <Path as PartialOrd>::partial_cmp(self.as_ref(), other)

1962: impl_cmp_os_str!(Path, OsStr);

1963: impl_cmp_os_str!(Path, &'a OsStr);

1964: impl_cmp_os_str!(Path, Cow<'a, OsStr>);

1965: impl_cmp_os_str!(Path, OsString);

1966: impl_cmp_os_str!(&'a Path, OsStr);

1967: impl_cmp_os_str!(&'a Path, Cow<'b, OsStr>);

1968: impl_cmp_os_str!(&'a Path, OsString);

1969: impl_cmp_os_str!(Cow<'a, Path>, OsStr);

1970: impl_cmp_os_str!(Cow<'a, Path>, &'b OsStr);

1971: impl_cmp_os_str!(Cow<'a, Path>, OsString);

32: //! and [`str`]), for working with paths abstractly. These types are thin wrappers

36: //! Paths can be parsed into [`Component`]s by iterating over the structure

40: //! [`PathBuf`]; note that the paths may differ syntactically by the

840: /// [`push`]: struct.PathBuf.html#method.push

841: /// [`set_extension`]: struct.PathBuf.html#method.set_extension

854:         unsafe { &mut *(self as *mut PathBuf as *mut Vec<u8>) }

857:     /// Allocates an empty `PathBuf`.

859:     pub fn new() -> PathBuf {

860:         PathBuf { inner: OsString::new() }

863:     /// Creates a new `PathBuf` with a given capacity used to create the

866:     pub fn with_capacity(capacity: usize) -> PathBuf {

867:         PathBuf {

930:     /// [`self.parent`]: struct.PathBuf.html#method.parent

952:     /// [`self.file_name`]: struct.PathBuf.html#method.file_name

954:     /// [`pop`]: struct.PathBuf.html#method.pop

976:     /// [`self.file_name`]: struct.PathBuf.html#method.file_name

977:     /// [`self.extension`]: struct.PathBuf.html#method.extension

1003:     /// Consumes the `PathBuf`, yielding its internal [`OsString`] storage.

1104:     fn from(s: &T) -> PathBuf {

1105:         PathBuf::from(s.as_ref().to_os_string())

1110:     /// Converts a `OsString` into a `PathBuf`

1113:     fn from(s: OsString) -> PathBuf {

1114:         PathBuf { inner: s }

1118: impl From<PathBuf> for OsString {

1119:     /// Converts a `PathBuf` into a `OsString`

1128:     /// Converts a `String` into a `PathBuf`

1131:     fn from(s: String) -> PathBuf {

1132:         PathBuf::from(OsString::from(s))

1140:         Ok(PathBuf::from(s))

1145:     fn from_iter<I: IntoIterator<Item = P>>(iter: I) -> PathBuf {

1146:         let mut buf = PathBuf::new();

1180:         PathBuf::new()

1249:     type Owned = PathBuf;

1250:     fn to_owned(&self) -> PathBuf {

1253:     fn clone_into(&self, target: &mut PathBuf) {

1259:     fn eq(&self, other: &PathBuf) -> bool {

1273:     fn partial_cmp(&self, other: &PathBuf) -> Option<cmp::Ordering> {

1279:     fn cmp(&self, other: &PathBuf) -> cmp::Ordering {

1299: /// see [`PathBuf`].

1303: /// [`PathBuf`]: struct.PathBuf.html

1374:     /// [`PathBuf`]: struct.PathBuf.html

1378:         PathBuf::from(self.inner.to_os_string())

1556:     /// [`PathBuf`]: struct.PathBuf.html

1557:     /// [`PathBuf::push`]: struct.PathBuf.html#method.push

1569:     /// Creates an owned [`PathBuf`] like `self` but with the given file name.

1571:     /// See [`PathBuf::set_file_name`] for more details.

1573:     /// [`PathBuf`]: struct.PathBuf.html

1574:     /// [`PathBuf::set_file_name`]: struct.PathBuf.html#method.set_file_name

1576:     pub fn with_file_name<S: AsRef<OsStr>>(&self, file_name: S) -> PathBuf {

1580:     fn _with_file_name(&self, file_name: &OsStr) -> PathBuf {

1586:     /// Creates an owned [`PathBuf`] like `self` but with the given extension.

1588:     /// See [`PathBuf::set_extension`] for more details.

1590:     /// [`PathBuf`]: struct.PathBuf.html

1591:     /// [`PathBuf::set_extension`]: struct.PathBuf.html#method.set_extension

1593:     pub fn with_extension<S: AsRef<OsStr>>(&self, extension: S) -> PathBuf {

1597:     fn _with_extension(&self, extension: &OsStr) -> PathBuf {

1645:     /// Returns an object that implements [`Display`] for safely printing paths

1687:     pub fn canonicalize(&self) -> io::Result<PathBuf> {

1698:     pub fn read_link(&self) -> io::Result<PathBuf> {

1772:     /// [`PathBuf`]: struct.PathBuf.html

1776:         PathBuf { inner: OsString::from(inner) }

1792: /// Helper struct for safely printing paths with [`format!`] and `{}`.

1958: impl_cmp_os_str!(PathBuf, OsStr);

1959: impl_cmp_os_str!(PathBuf, &'a OsStr);

1960: impl_cmp_os_str!(PathBuf, Cow<'a, OsStr>);

1961: impl_cmp_os_str!(PathBuf, OsString);

64: public class Path extends FilledElement

82:     public function Path()

1196: class PathSegmentsCollection

1214: public function PathSegmentsCollection(value:String)

1540: public function generateGraphicsPath(graphicsPath:GraphicsPath,

1742: public function PathSegment(_x:Number = 0, _y:Number = 0)

39:  *  The Path class is a filled graphic element that draws a series of path segments.

40:  *  In vector graphics, a path is a series of points connected by straight or curved line segments. 

41:  *  Together the lines form an image. In Flex, you use the Path class to define a complex vector shape 

44:  *  <p>Typically, the first element of a path definition is a Move segment to specify the starting pen 

51:  *  point of the line. You can use multiple Move segments in the path definition to 

54:  *  <p>The syntax used by the Path class to define the shape is the same as the SVG path syntax, 

94:      *  Dirty flag to indicate when path data has changed. 

105:      *  path segment information  

116:      *  commands to draw this Path.  

118:      *  The data commands expressed in a Path's <code>data</code> 

140:      *  A string containing a compact represention of the path segments. This is an alternate

144:      *  <p>The value is a space-delimited string describing each path segment. Each

198:      *      <td>Close path</td>

201:      *      <td>Closes off the path.</td>

245:      *  Fill rule for intersecting or overlapping path segments. 

322:      *  Returns the bounding box for the path including stroke, if the path is resized

406:      *  @return Returns the axis aligned bounding box of the path when

420:         // then the non-stroked path bounds for the give size can be

556:         // slow code-path Player execution for all graphics in that DisplayObject.

708:      *  if the path is resized to the specified size.

947:         // Resize transformed path with the iterative solution

962:         // the path size as the size changes the angles of the joints.

1193:  *  Path segments.

1452:  *  A Vector of the actual path segments. May be empty, but always non-null. 

1510:     // If path is empty, it's untransformed bounding box is (0,0), so we return transformed point (0,0)

1522:  *  array and draws each path egment based on its control points. 

1524:  *  Segments are drawn from the x and y position of the path. 

1526:  *  applied to the path. 

1529:  *  path segment should be drawn

1532:  *  path segment should be drawn

1535:  *  this path segment 

1538:  *  path segment

1550:     // the path will begin at the previous pen location

1712:  *  The PathSegment class is the base class for a segment of a path.

1794:  *  Draws this path segment. You can determine the current pen position by 

1817:  *  path segment.

24: import flash.display.GraphicsPath;

55:  *  which makes it easy to convert SVG paths to Flex paths.</p>

112:     private var segments:PathSegmentsCollection;

115:      *  A GraphicsPath object that contains the drawing 

123:     mx_internal var graphicsPath:GraphicsPath = new GraphicsPath(new Vector.<int>(), new Vector.<Number>());

218:         segments = new PathSegmentsCollection(value);

392:     private function tangentIsValid(prevSegment:PathSegment, curSegment:PathSegment,

418:         var pathBBox:Rectangle;

424:             pathBBox = new Rectangle(naturalBounds.x * sx,

429:                 pathBBox.offset(m.tx, m.ty);

433:             pathBBox = this.segments.getBoundingBox(width, height, m);

439:             return pathBBox;

441:         // Always add half the stroke weight, even for miter limit paths,

445:         pathBBox.inflate(strokeExtents.right, strokeExtents.bottom);

447:         var seg:Vector.<PathSegment> = segments.data;

453:             return pathBBox;

473:                 var prevSegment:PathSegment = start > 0 ? seg[start - 1] : null;

482:             var startSegment:PathSegment = seg[start];

519:             var endSegment:PathSegment = seg[end];

531:                     pathBBox);

538:         return pathBBox;

582:     private function addMiterLimitStrokeToBounds(segment0:PathSegment,

583:                                                  segment1:PathSegment,

584:                                                  segment2:PathSegment,

939:         // We have special handling for miter-limit stroked non-transformed paths,

1098:                 segments.generateGraphicsPath(graphicsPath, drawX, drawY, sx, sy);

1102:         g.drawPath(graphicsPath.commands, graphicsPath.data, winding);

1187: //  Internal Helper Class - PathSegmentsCollection

1194:  *  Provides methods for generating GraphicsPath and calculating bounds. 

1218:         _segments = new Vector.<PathSegment>();

1222:     var newSegments:Vector.<PathSegment> = new Vector.<PathSegment>();

1418:                 _segments = new Vector.<PathSegment>();

1449: private var _segments:Vector.<PathSegment>;

1454: public function get data():Vector.<PathSegment>

1499:     var prevSegment:PathSegment;

1500:     var pathBBox:Rectangle;

1505:         var segment:PathSegment = _segments[i];

1506:         pathBBox = segment.getBoundingBox(prevSegment, sx, sy, m, pathBBox);

1511:     if (!pathBBox)

1515:         pathBBox = new Rectangle(x, y);

1517:     return pathBBox;

1546:     graphicsPath.commands = null;

1547:     graphicsPath.data = null;

1552:     graphicsPath.moveTo(tx, ty);

1554:     var curSegment:PathSegment;

1555:     var prevSegment:PathSegment;

1561:         curSegment.draw(graphicsPath, tx, ty, sx, sy, prevSegment);

1702: //  Internal Helper Class - PathSegment 

1705: import flash.display.GraphicsPath;

1721: class PathSegment extends Object

1805: public function draw(graphicsPath:GraphicsPath, dx:Number,dy:Number,sx:Number,sy:Number,prev:PathSegment):void

1824: public function getBoundingBox(prev:PathSegment, sx:Number, sy:Number, m:Matrix, rect:Rectangle):Rectangle

1839: public function getTangent(prev:PathSegment, start:Boolean, sx:Number, sy:Number, m:Matrix, result:Point):void

1853: import flash.display.GraphicsPath;

1869: class LineSegment extends PathSegment

1911: override public function draw(graphicsPath:GraphicsPath, dx:Number,dy:Number,sx:Number,sy:Number,prev:PathSegment):void

1913:     graphicsPath.lineTo(dx + x*sx, dy + y*sy);

1924: override public function getBoundingBox(prev:PathSegment, sx:Number, sy:Number, m:Matrix, rect:Rectangle):Rectangle

1952: override public function getTangent(prev:PathSegment, start:Boolean, sx:Number, sy:Number, m:Matrix, result:Point):void

1967: import flash.display.GraphicsPath;

1981: class MoveSegment extends PathSegment

2024: override public function draw(graphicsPath:GraphicsPath, dx:Number,dy:Number,sx:Number,sy:Number,prev:PathSegment):void

2026:     graphicsPath.moveTo(dx+x*sx, dy+y*sy);

2036: import flash.display.GraphicsPath;

2061: class CubicBezierSegment extends PathSegment

2198:     override public function draw(graphicsPath:GraphicsPath, dx:Number, dy:Number, sx:Number, sy:Number, prev:PathSegment):void

2202:         graphicsPath.curveTo(dx + qPts.control1.x*sx, dy+qPts.control1.y*sy, dx+qPts.anchor1.x*sx, dy+qPts.anchor1.y*sy)...(1 bytes skipped)...

2203:         graphicsPath.curveTo(dx + qPts.control2.x*sx, dy+qPts.control2.y*sy, dx+qPts.anchor2.x*sx, dy+qPts.anchor2.y*sy)...(1 bytes skipped)...

2204:         graphicsPath.curveTo(dx + qPts.control3.x*sx, dy+qPts.control3.y*sy, dx+qPts.anchor3.x*sx, dy+qPts.anchor3.y*sy)...(1 bytes skipped)...

2205:         graphicsPath.curveTo(dx + qPts.control4.x*sx, dy+qPts.control4.y*sy, dx+qPts.anchor4.x*sx, dy+qPts.anchor4.y*sy)...(1 bytes skipped)...

2216:     override public function getBoundingBox(prev:PathSegment, sx:Number, sy:Number,

2252:     override public function getTangent(prev:PathSegment, start:Boolean, sx:Number, sy:Number, m:Matrix, result:Point):void

2318:     private function getQuadraticPoints(prev:PathSegment):QuadraticPoints

2411: import flash.display.GraphicsPath;

2431: class QuadraticBezierSegment extends PathSegment

2526:     override public function draw(graphicsPath:GraphicsPath, dx:Number,dy:Number,sx:Number,sy:Number,prev:PathSegment):void

2528:         graphicsPath.curveTo(dx+control1X*sx, dy+control1Y*sy, dx+x*sx, dy+y*sy);

2574:     override public function getTangent(prev:PathSegment, start:Boolean, sx:Number, sy:Number, m:Matrix, result:Point):void

2591:     override public function getBoundingBox(prev:PathSegment, sx:Number, sy:Number,

101:     private var graphicsPathChanged:Boolean = true;

220:         graphicsPathChanged = true;

246:      *  Possible values are <code>GraphicsPathWinding.EVEN_ODD</code> or <code>GraphicsPathWinding.NON_ZERO</code>.

250:      *  @see flash.display.GraphicsPathWinding 

262:             graphicsPathChanged = true;

1085:             graphicsPathChanged = true;

1092:         if (graphicsPathChanged)

1099:             graphicsPathChanged = false;

1139:         graphicsPathChanged = true;

43: class Path:

114: path = Path()

30: <path id="%s" transform="translate (%d,%d)"

55:             path.name = namematch.group(1)

59:                path.gimppoints.append ([])

61:             path.gimppoints[-1].append (map (int, pointmatch.groups()))

71:       for path in self.gimppoints:

72:          if path:

73:             start = path[0]

75:             path = path[1:]

76:             while path:

77:                curve = path [0:3]

78:                path = path[3:]

115: path.readgimpfile (infile)

116: path.makesvg()

117: path.writesvgfile (outfile)

6: gimppath2svg.py -- Converts Gimp-Paths to a SVG-File.

23: Usage: gimppath2svg.py [infile [outfile]]

46:       self.svgpath = ""

89:             self.svgpath = self.svgpath + svg

92:       if self.svgpath:

97:                               self.svgpath)

12: class Path(object):

13:     def __init__(self, path):

14:         if isinstance(path, Path):

15:             _path = path._path

17:             _path = ensure_text(path)

19:                 _path = _path.encode("utf-8")

20:         self._path = _path

23:         return ensure_str("Path({})".format(ensure_text(self._path)))

26:         return ensure_text(self._path)

29:         return ensure_str(self._path)

32:         if isinstance(other, Path):

33:             right = other._path

38:         return Path(os.path.join(self._path, right))

44:         return self._path == (other._path if isinstance(other, Path) else None)

50:         return hash(self._path)

53:         return os.path.exists(self._path)

57:         return Path(os.path.abspath(os.path.join(self._path, os.path.pardir)))

60:         return Path(os.path.realpath(self._path))

64:         return os.path.basename(self._path)

68:         return self._path.split(os.sep)

71:         return os.path.isfile(self._path)

74:         return os.path.isdir(self._path)

78:             os.makedirs(self._path)

84:         with open(self._path, "rb") as file_handler:

88:         with open(self._path, "wb") as file_handler:

92:         for p in os.listdir(self._path):

93:             yield Path(os.path.join(self._path, p))

97:         _, ext = os.path.splitext(self.name)

102:         base, _ = os.path.splitext(self.name)

107:         with open(self._path, mode) as file_handler:

115:             result.append(Path(os.sep.join(parts[0 : i + 1])))

119:         os.remove(self._path)

125:         return os.path.islink(self._path)

128:         if not self._path.startswith(other._path):

129:             raise ValueError("{} does not start with {}".format(self._path, other._path))

130:         return Path(os.sep.join(self.parts[len(other.parts) :]))

133:         return os.stat(self._path)

136:         os.chmod(self._path, mode)

139: __all__ = ("Path",)

26: type Path []PathStep

34: type PathStep interface {

151: type pathStep struct {

172: 	pathStep

210: 	pathStep

255: 	pathStep

269: 	pathStep

279: 	pathStep

289: 	pathStep

334: type pointerPath struct {

17: // Path is a list of PathSteps describing the sequence of operations to get

19: // The first Path element is always an operation-less PathStep that exists

37: 	// Type is the resulting type after performing the path step.

40: 	// Values is the resulting values after performing the path step.

65: func (pa *Path) push(s PathStep) {

69: func (pa *Path) pop() {

73: // Last returns the last PathStep in the Path.

74: // If the path is empty, this returns a non-nil PathStep that reports a nil Type.

75: func (pa Path) Last() PathStep {

79: // Index returns the ith step in the Path and supports negative indexing.

80: // A negative index starts counting from the tail of the Path such that -1

83: func (pa Path) Index(i int) PathStep {

93: // String returns the simplified path to a node.

94: // The simplified path only contains struct field accesses.

98: func (pa Path) String() string {

108: // GoString returns the path to a specific node using Go syntax.

112: func (pa Path) GoString() string {

328: // Path for whether px was ever encountered in the Path history of x, and

333: // in O(1) instead of O(N) where N is len(Path).

28: // PathStep is a union-type for specific operations to traverse

57: 	_ PathStep = StructField{}

58: 	_ PathStep = SliceIndex{}

59: 	_ PathStep = MapIndex{}

60: 	_ PathStep = Indirect{}

61: 	_ PathStep = TypeAssertion{}

62: 	_ PathStep = Transform{}

82: // If index is invalid, this returns a non-nil PathStep that reports a nil Type.

88: 		return pathStep{}

116: 		var nextStep PathStep

156: func (ps pathStep) Type() reflect.Type             { return ps.typ }

157: func (ps pathStep) Values() (vx, vy reflect.Value) { return ps.vx, ps.vy }

158: func (ps pathStep) String() string {

307: // pointerPath represents a dual-stack of pointers encountered when

312: // The pointerPath uses a map to represent a stack; where descension into a

330: // equal if both px and py have a cycle resulting from the same PathStep.

341: func (p *pointerPath) Init() {

353: func (p pointerPath) Push(vx, vy reflect.Value) (equal, visited bool) {

368: func (p pointerPath) Pop(vx, vy reflect.Value) {

6: package path

76: 		o.Array = obj.(Path)

113: 	Package: "path",

116: 		{Declared: "Array", Type: &schema.Interface{Name: "Path"}},

163: 	Package: "path",

218: 	Package: "path",

284: 	Package: "path",

334: 	Package: "path",

383: 	Package: "path",

412: 		o.Struct = obj.(Path)

449: 	Package: "path",

452: 		{Declared: "Struct", Type: &schema.Interface{Name: "Path"}},

505: 	Package: "path",

554: 	Package: "path",

592: 		o.Map = obj.(Path)

633: 	Package: "path",

636: 		{Declared: "Map", Type: &schema.Interface{Name: "Path"}},

722: 	Package: "path",

780: 	Package: "path",

812: 		o.Array = obj.(Path)

857: 	Package: "path",

860: 		{Declared: "Array", Type: &schema.Interface{Name: "Path"}},

914: 	Package: "path",

963: 	Package: "path",

5:     <path id="path" d="M0 0 L1 1 L0 1 Z"/>

8: <div style="width: 200px; height: 200px; background: blue; clip-path: url(#clip); will-change: transform"></div>

11:   path.setAttribute('d', 'M0 0 L1 0 L1 1 L0 1 Z');

4: 	<clipPath id="clip" clipPathUnits='objectBoundingBox'>

6: 	</clipPath>

3: const path = require('path');

14:   pathMismatch(npmRoot) {

29: function fixPath(filepath) {

48:   const nodePaths = (process.env.NODE_PATH || '').split(path.delimiter).map(fixPath);

7: exports.description = 'NODE_PATH matches the npm root';

11:     return message.get('node-path-npm-failure', {});

15:     let msgPath = 'node-path-path-mismatch';

22:       path: process.env.NODE_PATH,

30:   let fixedPath = path.resolve(path.normalize(filepath.trim()));

44:   if (process.env.NODE_PATH === undefined) {

18:       msgPath += '-windows';

21:     return message.get(msgPath, {

33:     fixedPath = fs.realpathSync(fixedPath);

40:   return fixedPath;

52:     const npmRoot = fixPath(stdout);

55:       return errors.pathMismatch(npmRoot);

54:     if (nodePaths.indexOf(npmRoot) < 0) {

2981: cXSAnyURI.prototype.path		= null;

6341: oObject.xpath	= function(oQuery, sExpression, fNSResolver) {

6307: function fXPath_evaluate(oQuery, sExpression, fNSResolver) {

1879: function cPathExpr() {

1885: function fPathExpr_parse (oLexer, oStaticContext) {

72: oException_messages["XPTY0018"]	= "The result of the last step in a path expression contains both nodes and atomic values";

73: oException_messages["XPTY0019"]	= "The result of a step (other than the last step) in a path expression contains an atomic value.";

1905: 					, "Expected path step expression"

1917: 					, "Expected path step expression"

2970: 	this.path		= sPath;

2988: 			+ (this.path ? this.path : '')

4951: 				if (oUri.path.charAt(0) != '/') {

4952: 			var aUriSegments		= oUri.path.split('/'),

4953: 				aBaseUriSegments	= oBaseUri.path.split('/');

4972: 						oUri.path	= aBaseUriSegments.join('/');

2:  * jQuery XPath plugin v0.2.5

3:  * https://github.com/ilinsky/jquery-xpath

7:  * Includes xpath.js - XPath 2.0 implementation in JavaScript

8:  * https://github.com/ilinsky/xpath.js

47: 	sNS_XPF	= "http://www.w3.org/2005/xpath-functions",

2967: function cXSAnyURI(sScheme, sAuthority, sPath, sQuery, sFragment) {

6079: 			fResolveUri	= oLXDOMAdapter_staticContext.getFunction('{' + "http://www.w3.org/2005/xpath-functions" + '}' + "resolve-uri"),

6302: oHTMLStaticContext.defaultFunctionNamespace	= "http://www.w3.org/2005/xpath-functions";

6342: 	return fXPath_evaluate(oQuery instanceof cQuery ? oQuery : new cQuery(oQuery), sExpression, fNSResolver);

6347: oObject.xpath	= function(sExpression, fNSResolver) {

6348: 	return fXPath_evaluate(this, sExpression, fNSResolver);

1569: 	return fPathExpr_parse(oLexer, oStaticContext);

1883: cPathExpr.prototype.items	= null;

1891: 	var oPathExpr	= new cPathExpr(),

1896: 		oPathExpr.items.push(new cFunctionCall(null, "root", sNS_XPF));

1898: 			oPathExpr.items.push(new cAxisStep("descendant-or-self", new cKindTest("node")));

1903: 			return oPathExpr.items[0];			if (sSlash == sDoubleSlash)

1909: 	oPathExpr.items.push(oExpr);

1913: 			oPathExpr.items.push(new cAxisStep("descendant-or-self", new cKindTest("node")));

1919: 				oPathExpr.items.push(oExpr);

1922: 	if (oPathExpr.items.length == 1)

1923: 		return oPathExpr.items[0];

1925: 		return oPathExpr;

1928: cPathExpr.prototype.evaluate	= function (oContext) {

3: var path = require("path");

453:                 path: scope,

522:                 path: "",

62: function resolveScopeCountPath(scope) {

142: var pathVisitor = walk.make({

557: module.exports.mapLinesPathToScopePath = function(ternServer, defInfo) {

607: module.exports.getPath = function(node) {

47: function getFilePathName(fileName) {

19:  * @property {string} scope - scope path

28:  * @property {string} path - path to class

36:  * @return {string} path to given node in given file

100:  * required parent properties and adjusting path

102:  * @param {string} scope new scope (path)

316:             if (def && def.path) {

317:                 pathMap[formPathForScope(fileName, node.object)] = def.path;

318:                 newScope = def.path;

326:                 if (def && def.path) {

327:                     pathMap[formPathForScope(fileName, node.object)] = def.path;

328:                     newScope = def.path;

341:                     newScope = util.formPath(def.path, "fn", '+' + node.property.name);

344:                     newScope = util.formPath(def.path, "fn", '-' + node.property.name);

347:                     newScope = util.formPath(def.path, "fn", node.property.name);

350:                     newScope = util.formPath(classDefinitions[currentClass].path, "prop", node.property.name);

438:             // append /class/NAME to path being built

443:                 classDefinitions[currentClass].path = scope;

605:  * @returns {string} computed path to given node

39:     return util.formPath(fileName, data.start, data.end);

48:     fileName = util.normalizePath(fileName);

69:         return util.formPath(scope, scopeCountRes);

73: module.exports.pathMap = pathMap = {};

154:             var newScope = util.formPath(scopeInfo.scope, "obj_def_prop");

158:                 newScope = util.formPath(newScope, obj.name);

160:                 newScope = util.formPath(newScope, property.value);

164:             pathMap[key] = resolveScopeCountPath(newScope);

179:         var newScope = util.formPath(scopeInfo.scope, "import");

185:                     newScope = resolveScopeCountPath(util.formPath(newScope, id.name));

186:                     pathMap[key] = newScope;

204:         var newScope = util.formPath(scopeInfo.scope, "fn");

223:             newScope = resolveScopeCountPath(util.formPath(newScope, name));

224:             pathMap[formPathForScope(fileName, identNode)] = newScope;

228:             newScope = resolveScopeCountPath(newScope);

240:             var paramScope = resolveScopeCountPath(util.formPath(newScope, "param", param.name));

241:             pathMap[formPathForScope(fileName, param)] = paramScope;

267:                 var newScope = resolveScopeCountPath(util.formPath(scopeInfo.scope, "var", decl.name));

268:                 pathMap[key] = newScope;

309:             newScope = resolveScopeCountPath(util.formPath(scopeInfo.scope, "obj", node.object.name));

310:             pathMap[formPathForScope(fileName, node.object)] = newScope;

353:                 newScope = resolveScopeCountPath(util.formPath(newScope, "prop", node.property.name));

356:             pathMap[keyProp] = newScope;

371:         var newScope = util.formPath(scopeInfo.scope, "obj");

375:                 objScope = util.formPath(objScope, "objType", node.objType.name);

378:             var keyScope = util.formPath(objScope, "obj_key");

382:                 keyScope = resolveScopeCountPath(util.formPath(keyScope, node.properties[i].key.name));

383:                 pathMap[keyKey] = keyScope;

387:                 keyScope = resolveScopeCountPath(util.formPath(keyScope, node.properties[i].key.value));

388:                 pathMap[keyKey] = keyScope;

395:                 valScope = resolveScopeCountPath(util.formPath(valScope, "obj_val", node.properties[i].value.name));

396:                 pathMap[key_val] = valScope;

436:         var scope = util.formPath(scopeInfo.scope, "class");

439:             scope = resolveScopeCountPath(util.formPath(scope, node.id.name));

440:             pathMap[formPathForScope(node.sourceFile.name, node.id)] = scope;

446:             scope = resolveScopeCountPath(scope);

457:             pathMap[util.formPath(node.sourceFile.name, node.start, node.start + "class".length)] = scope;

513:     var visitor = extend({}, pathVisitor);

530:         pathVisitor.ClassDeclaration(node, state, cb);

543:         pathVisitor.MethodDefinition(node, state, cb);

562:     var mapRes = pathMap[key];

577:                     methods: pathVisitor

578:                 }, null, pathVisitor);

608:     return pathMap[formPathForScope(node.sourceFile.name, node)];

38: module.exports.formPathForScope = formPathForScope = function(fileName, data) {

163:             var key = formPathForScope(fileName, property);

184:                     var key = formPathForScope(fileName, id);

266:                 var key = formPathForScope(fileName, decl);

355:             keyProp = formPathForScope(fileName, node.property);

381:                 keyKey = formPathForScope(fileName, node.properties[i].key);

386:                 keyKey = formPathForScope(fileName, node.properties[i].key);

394:                 var key_val = formPathForScope(fileName, node.properties[i].value);

508: module.exports.initLocalFilesScopePaths = function(ternServer, localFiles) {

550:                 scope: getFilePathName(file.name),

558:     var key = formPathForScope(defInfo.file, {

575:                     scope: getFilePathName(file.name),

22:   const string& path() const { return path_; }

25:   string path_;

17: class ScopedTempPath {

19:   ScopedTempPath() {}

6: #define CHROMIUMOS_WIDE_PROFILING_SCOPED_TEMP_PATH_H_

5: #ifndef CHROMIUMOS_WIDE_PROFILING_SCOPED_TEMP_PATH_H_

20:   // The temporary path will be removed when the object is destroyed.

33:   // Create a temporary file.  If successful, the path will be stored in

34:   // |path_|.  If not, |path_| will be an empty string.

43:   // Create a temporary directory.  If successful, the path will be stored in

44:   // |path_|.  If not, |path_| will be an empty string.

53: #endif  // CHROMIUMOS_WIDE_PROFILING_SCOPED_TEMP_PATH_H_

21:   virtual ~ScopedTempPath();

28:   DISALLOW_COPY_AND_ASSIGN(ScopedTempPath);

31: class ScopedTempFile : public ScopedTempPath {

41: class ScopedTempDir : public ScopedTempPath {

60: class Path : public ThreadCapture<Path> {

56:   std::ostringstream path_;

34: class PathBuilder {

85:   static std::string DelegateRootPath(const Path& path) {

89:   static void DelegateLocalPath(const Path& path, PathBuilder* builder) {

95: class InRootPath : public Path {

97:   InRootPath(const std::string& root_path)

101:   std::string RootPath() const override { return root_path_; }

103:   void AppendLocalPath(PathBuilder* builder) const override {

116: class InLocalPath : public Path {

118:   InLocalPath(const std::string& local_path)

122:   std::string RootPath() const override {

127:   void AppendLocalPath(PathBuilder* builder) const override {

111:   const std::string root_path_;

137:   const std::string local_path_;

36:   std::string String() const { return path_.str(); }

41:         path_.str("");

42:         path_ << component;

45:           path_ << '/';

47:         path_ << component;

86:     return path.RootPath();

90:     path.AppendLocalPath(builder);

94: // Sets the root path, which persists while the instance is in scope.

98:       : root_path_(root_path), capture_to_(this) {}

115: // Sets the local path relative to the current root + local path.

119:       : local_path_(local_path), capture_to_(this) {}

133:     builder->Add(local_path_);

143:   InLocalPath path("bin");

146:     std::cerr << "Installing binary " << Path::Working() << std::endl;

152:   InLocalPath path("lib");

155:     std::cerr << "Installing library " << Path::Working() << std::endl;

160: void InstallProjectIn(const std::string& path) {

161:   InRootPath root(path);

162:   std::cerr << "Installing project in " << Path::Root() << std::endl;

33: // A helper class for building paths from components.

38:   PathBuilder& Add(const std::string& component) {

59: // Tracks persistent root and local paths.

64:       return GetCurrent()->RootPath();

72:       PathBuilder builder;

74:       GetCurrent()->AppendLocalPath(&builder);

82:   virtual std::string RootPath() const = 0;

83:   virtual void AppendLocalPath(PathBuilder* builder) const = 0;

106:       DelegateLocalPath(*previous, builder);

124:     return previous ? DelegateRootPath(*previous) : "";

131:       DelegateLocalPath(*previous, builder);

145:     InLocalPath file(target);

154:     InLocalPath file(target);

24: type Path struct {

39: func StringToPath(s string) (*Path, error) {

49: func sliceToPath(slice []string) (*Path, error) {

69: func encodePath(s string) (*Path, error) {

23: // Path to a specific variable

29: 	// Name of struct field in path

33: 	// if nil, this Path refers to the top-level element

34: 	Next *Path

37: // Converts a string to a Path pointer. If the pointer is nil,

38: // the Path refers to the top-level ("current") element.

47: // Converts a string slice to a Path pointer. If the pointer is nil,

48: // the Path refers to the top-level ("current") element.

50: 	var first *Path

51: 	var cur *Path

68: // Encodes path part

75: 		return &Path{

80: 	return &Path{

85: // Appends the specified newElement to the path and

86: // returns the new root of the path.

87: func (p *Path) Append(newElement *Path) *Path {

88: 	var prevEl *Path

89: 	var curEl *Path

100: // Removes the last element from the path and returns

101: // the new root of the path

102: func (p *Path) RemoveLast() *Path {

106: 	var prevEl *Path

107: 	var curEl *Path

114: type VisitingFunc func(updatedPath *Path)

116: // Attaches the specified element to the path, runs the specified function, and

119: func (p *Path) Visiting(element *Path, doing VisitingFunc) {

125: func (p *Path) String() string {

44: 	return sliceToPath(sliced)

53: 		pathEl, err := encodePath(elt)

58: 			first = pathEl

60: 			cur.Next = pathEl

62: 		cur = pathEl

129: 	subpath := p.Next.String()

134: 	if subpath == "" {

137: 		return elt + "." + subpath

35:   const std::string Path() const { return path_; }

43:   std::string path_;

26: class FilePath {

28:   FilePath() {}

30:   FilePath(const FilePath &other) { path_ = other.path_; }

32:   FilePath(const std::string &path) {

18: #define VISQOL_INCLUDE_FILEPATH_H

46: struct ReferenceDegradedPathPair {

33:       path_ = ::boost::filesystem::path(path).string(); }

37:   bool Exists() const { return ::boost::filesystem::exists(path_); }

40:       return ::boost::filesystem::current_path().string(); }

17: #ifndef VISQOL_INCLUDE_FILEPATH_H

47:   FilePath reference;

48:   FilePath degraded;

52: #endif  // VISQOL_INCLUDE_FILEPATH_H

1: package path;

13: const path = require('path').posix;

35:       const pathname = path.relative(

36:         path.dirname(parsedFrom.pathname), parsedTo.pathname);

54:       let path = match.replace(/["']/g, "").slice(4, -1);

55:       path = this.rewriteRelPath(importUrl, mainDocUrl, path);

56:       return 'url("' + path + '")';

12: // Adapted from vulcanize's pathResolver, but only used for css text

26:   rewriteRelPath: function rewriteRelPath(importUrl, mainDocUrl, relUrl) {

38:         pathname,

18: package path

26: type Path []string

44: func ToPaths(paths []string) []Path {

17: // Package path implements path manipulation routines used by cmaketobzl.

21: 	"path/filepath"

25: // Path is a slice of string segments, representing a filesystem path.

28: // Split cleans and splits the system-delimited filesystem path.

29: func New(s string) Path {

35: 		return Path{"/"}

37: 		return append(Path{"/"}, strings.Split(s[1:], "/")...)

45: 	split := make([]Path, len(paths))

53: func (p Path) LessThan(o Path) bool {

66: // String returns the properly platform-delimited form of the path.

67: func (p Path) String() string {

71: // Append appends additional elements to the end of path, disregarding

73: func Append(p Path, ps ...Path) Path {

84: // AppendString appends additional string elements to the end of path.

85: func AppendString(p Path, elem ...string) Path {

90: func Join(p Path, ps ...Path) Path {

97: // JoinString joins path and any number of additional string elements, returning the result.

98: func JoinString(p Path, elem ...string) Path {

103: // path and returns that along with each path stripped of that prefix.

104: func SplitCommonRoot(paths []Path) (Path, []Path) {

109: 	result := make([]Path, len(paths))

117: // path and returns that along with each path stripped of that prefix as /-delimited strings.

127: // LongestCommonPrefix returns the longest shared Path prefix of all of the paths.

128: func LongestCommonPrefix(paths []Path) Path {

30: 	s = filepath.ToSlash(filepath.Clean(s))

43: // ToPaths cleans and splits each of the system-delimited filesystem paths.

46: 	for i, p := range paths {

52: // LessThan provides lexicographic ordering of Paths.

68: 	return filepath.Join([]string(p)...)

75: 		// Drop the leading '/' when appending/joining fully qualified paths.

89: // Join joins any number of paths and returns the result.

105: 	root := LongestCommonPrefix(paths)

107: 		return root, paths

110: 	for i, p := range paths {

118: func SplitCommonRootString(paths []string) (string, []string) {

119: 	root, stripped := SplitCommonRoot(ToPaths(paths))

129: 	switch len(paths) {

133: 		return paths[0]

135: 	min, max := paths[0], paths[0]

136: 	for _, p := range paths[1:] {

86: 	return Append(p, ToPaths(elem)...)

99: 	return Join(p, ToPaths(elem)...)

39: message Path {

24: // A path is a more general substitute for the name of a field or feature that

32: // Thus, here the path {step:["parent", "age"]} in statistics would refer to the

7:             "path": "/myapp:myName/myapp:myChildNode/aSubChildNode",

8:             "type": "Path"

11:         "requiredType": "Path",

20:         "name": "pathPropertyDef"

9535: 	Path string                 `xml:"path"`

16915: 	Path         string     `xml:"path"`

17155: 	Path       string                 `xml:"path"`

18138: 	Path       string                  `xml:"path"`

21824: 	Path               string `xml:"path,omitempty"`

21861: 	Path                   []HostMultipathInfoPath                             `xml:"path"`

21910: 	Path []HostMultipathStateInfoPath `xml:"path,omitempty"`

22603: 	Path    []HostPlugStoreTopologyPath    `xml:"path,omitempty"`

22618: 	Path    []string `xml:"path,omitempty"`

22630: 	Path []string `xml:"path,omitempty"`

23031: 	Path string                 `xml:"path"`

27814: 	Path string `xml:"path,omitempty"`

28964: 	Path  string               `xml:"path"`

31651: 	Path              string `xml:"path"`

31667: 	Path              string `xml:"path"`

33986: 	Path    *ProfilePropertyPath `xml:"path,omitempty"`

37442: 	Path string                  `xml:"path"`

37469: 	Path string                 `xml:"path"`

37539: 	Path       string                  `xml:"path"`

43419: 	Path      string              `xml:"path"`

1241: 	UserInputPath ProfilePropertyPath `xml:"userInputPath"`

1281: 	UserInputPath ProfilePropertyPath `xml:"userInputPath"`

3050: type ArrayOfHostMultipathInfoPath struct {

3051: 	HostMultipathInfoPath []HostMultipathInfoPath `xml:"HostMultipathInfoPath,omitempty"`

3058: type ArrayOfHostMultipathStateInfoPath struct {

3059: 	HostMultipathStateInfoPath []HostMultipathStateInfoPath `xml:"HostMultipathStateInfoPath,omitempty"`

3226: type ArrayOfHostPlugStoreTopologyPath struct {

3227: 	HostPlugStoreTopologyPath []HostPlugStoreTopologyPath `xml:"HostPlugStoreTopologyPath,omitempty"`

4442: type ArrayOfProfilePropertyPath struct {

4443: 	ProfilePropertyPath []ProfilePropertyPath `xml:"ProfilePropertyPath,omitempty"`

5657: 	VmfsPath string                 `xml:"vmfsPath"`

5902: 	FilePath        string                            `xml:"filePath"`

6731: 	GuestFilePath  string                  `xml:"guestFilePath"`

8433: 	ApplyPath      ProfilePropertyPath `xml:"applyPath"`

8504: 	DevicePath      string                  `xml:"devicePath"`

8784: 	DevicePath []string               `xml:"devicePath,omitempty"`

8815: 	PropertyPath string                  `xml:"propertyPath"`

8899: type ConvertNamespacePathToUuidPath ConvertNamespacePathToUuidPathRequestType

9869: 	DirectoryPath string                  `xml:"directoryPath,omitempty"`

9892: 	DirectoryPath string                  `xml:"directoryPath,omitempty"`

11926: 	OldMountPath string                 `xml:"oldMountPath"`

12151: 	DirectoryPath string                  `xml:"directoryPath"`

12165: 	DatastorePath string                  `xml:"datastorePath"`

12191: 	FilePath string                  `xml:"filePath"`

12203: 	DatastorePath string                 `xml:"datastorePath"`

12654: 	VffsPath string                 `xml:"vffsPath"`

13030: type DisableMultipathPath DisableMultipathPathRequestType

13038: 	PathName string                 `xml:"pathName"`

15248: type EnableMultipathPath EnableMultipathPathRequestType

15256: 	PathName string                 `xml:"pathName"`

15891: 	VmfsPath string                 `xml:"vmfsPath"`

16116: 	VffsPath   string                 `xml:"vffsPath"`

16117: 	DevicePath string                 `xml:"devicePath"`

16510: 	MetaDataPath    *FaultToleranceMetaSpec     `xml:"metaDataPath,omitempty"`

17146: type FindByDatastorePath FindByDatastorePathRequestType

17187: type FindByInventoryPath FindByInventoryPathRequestType

17195: 	InventoryPath string                 `xml:"inventoryPath"`

18114: 	DiskPath  string `xml:"diskPath,omitempty"`

18388: 	ProgramPath      string   `xml:"programPath"`

18401: 	RegistryPath string `xml:"registryPath"`

19891: 	FolderPath string                  `xml:"folderPath,omitempty"`

20178: 	DevicePath string                `xml:"devicePath,omitempty"`

21622: 	LocalPath string `xml:"localPath"`

21890: type HostMultipathInfoPath struct {

21895: 	PathState     string                  `xml:"pathState"`

21897: 	IsWorkingPath *bool                   `xml:"isWorkingPath"`

21917: type HostMultipathStateInfoPath struct {

21921: 	PathState string `xml:"pathState"`

21932: 	RemotePath       string   `xml:"remotePath"`

21958: 	RemotePath      string   `xml:"remotePath"`

21959: 	LocalPath       string   `xml:"localPath"`

22637: type HostPlugStoreTopologyPath struct {

22660: 	ClaimedPath []string `xml:"claimedPath,omitempty"`

23241: 	DevicePath            string                `xml:"devicePath"`

23905: 	DevicePath   string                `xml:"devicePath"`

23921: 	ExtentDevicePath []string `xml:"extentDevicePath"`

23943: 	ExtentDevicePath []string `xml:"extentDevicePath"`

24082: 	DevicePath              []string                      `xml:"devicePath,omitempty"`

24146: 	DevicePath   string                 `xml:"devicePath"`