isDir() публичный Метод

public isDir ( ) : bool
Результат bool
Пример #1
0
 public LocalFile(Uri uri, FileSystemInfo file)
     : base(uri)
 {
     this.m_file = file;
       if (System.IO.Directory.Exists(file.FullName))
       {
     if (!uri.isDir())
       throw IOErr.make("Must use trailing slash for dir: " + uri).val;
       }
       else if (System.IO.File.Exists(file.FullName))
       {
     if (uri.isDir())
       throw IOErr.make("Cannot use trailing slash for file: " + uri).val;
       }
 }
Пример #2
0
 public static string uriToPath(Uri uri)
 {
     string path = uri.m_pathStr;
       bool dir = uri.isDir();
       int len = path.Length;
       StringBuilder s = new StringBuilder(path.Length);
       for (int i=0; i<len; ++i)
       {
     int c = path[i];
     if (i == 0 && c == '/' && path.Contains(":")) continue;  // skip abs
     if (i == len-1 && c == '/' && dir) continue;  // skip trailing slash
     switch (c)
     {
       case '\\': break;
       case '/':  s.Append('\\'); break;
       default:   s.Append((char)c); break;
     }
       }
       return s.ToString();
 }
Пример #3
0
Файл: Uri.cs Проект: xored/f4
        static void merge(Sections t, Uri baseUri, Uri r)
        {
            bool baseIsAbs = baseUri.isPathAbs();
              bool baseIsDir = baseUri.isDir();
              bool rIsDir    = r.isDir();
              List rPath     = r.m_path;
              bool dotLast   = false;

              // compute the target path taking into account whether
              // the base is a dir and any dot segments in relative ref
              List tPath;
              if (baseUri.m_path.sz() == 0)
              {
            tPath = r.m_path;
              }
              else
              {
            tPath = baseUri.m_path.rw();
            if (!baseIsDir) tPath.pop();
            for (int i=0; i<rPath.sz(); ++i)
            {
              string rSeg = (string)rPath.get(i);
              if (rSeg == ".") { dotLast = true; continue; }
              if (rSeg == "..")
              {
            if (!tPath.isEmpty()) { tPath.pop(); dotLast = true; continue; }
            if (baseIsAbs) continue;
              }
              tPath.add(rSeg); dotLast = false;
            }
            //tPath = tPath;
              }

              t.path = tPath;
              t.pathStr = toPathStr(baseIsAbs, tPath, rIsDir || dotLast);
        }
Пример #4
0
 public static FileSystemInfo uriToFile(Uri uri)
 {
     if (uri.scheme() != null && uri.scheme() != "file")
     throw ArgErr.make("Invalid Uri scheme for local file: " + uri).val;
       string path = uriToPath(uri);
       if (System.IO.Directory.Exists(path)) return new DirectoryInfo(path);
       if (System.IO.File.Exists(path)) return new FileInfo(path);
       if (uri.isDir()) return new DirectoryInfo(path);
       return new FileInfo(path);
 }
Пример #5
0
Файл: Uri.cs Проект: xored/f4
        //////////////////////////////////////////////////////////////////////////
        // Relativize
        //////////////////////////////////////////////////////////////////////////
        public Uri relTo(Uri baseUri)
        {
            if (!OpUtil.compareEQ(this.m_scheme,   baseUri.m_scheme) ||
              !OpUtil.compareEQ(this.m_userInfo, baseUri.m_userInfo) ||
              !OpUtil.compareEQ(this.m_host,     baseUri.m_host) ||
              !OpUtil.compareEQ(this.m_port,     baseUri.m_port))
            return this;

              // at this point we know we have the same scheme and auth, and
              // we're going to create a new URI which is a subset of this one
              Sections t = new Sections();
              t.query    = this.m_query;
              t.queryStr = this.m_queryStr;
              t.frag     = this.m_frag;

              // find divergence
              int d=0;
              int len = Math.Min(this.m_path.sz(), baseUri.m_path.sz());
              for (; d<len; ++d)
            if (!this.m_path.get(d).Equals(baseUri.m_path.get(d)))
              break;

              // if diverenge is at root, then no commonality
              if (d == 0)
              {
            // `/a/b/c`.relTo(`/`) should be `a/b/c`
            if (baseUri.m_path.isEmpty() && this.m_pathStr.StartsWith("/"))
            {
              t.path = this.m_path;
              t.pathStr = this.m_pathStr.Substring(1);
            }
            else
            {
              t.path = this.m_path;
              t.pathStr = this.m_pathStr;
            }
              }

              // if paths are exactly the same
              else if (d == this.m_path.sz() && d == baseUri.m_path.sz())
              {
            t.path = emptyPath();
            t.pathStr = string.Empty;
              }

              // create sub-path at divergence point
              else
              {
            // slice my path
            t.path = this.m_path.getRange(Range.makeInclusive(d, -1));

            // insert .. backup if needed
            int backup = baseUri.m_path.sz() - d;
            if (!baseUri.isDir()) backup--;
            while (backup-- > 0) t.path.insert(0, dotDot);

            // format the new path string
            t.pathStr = toPathStr(false, t.path, this.isDir());
              }

              return new Uri(t);
        }