native_client_sdk/src/libraries/nacl_io/path.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "nacl_io/path.h"
   6
   7 #include <stdio.h>
   8 #include <string.h>
   9 #include <string>
  10
  11 #include "sdk_util/string_util.h"
  12
  13 namespace nacl_io {
  14
  15 Path::Path(const Path& path) {
  16   paths_ = path.paths_;
  17 }
  18
  19 Path::Path(const std::string& path) {
  20   Set(path);
  21 }
  22
  23 bool Path::IsAbsolute() const {
  24   return !paths_.empty() && paths_[0] == "/";
  25 }
  26
  27 const std::string& Path::Part(size_t index) const {
  28   return paths_[index];
  29 }
  30
  31 size_t Path::Size() const {
  32   return paths_.size();
  33 }
  34
  35 bool Path::IsRoot() const {
  36   return paths_.empty() || (paths_.size() == 1 && paths_[0] == "/");
  37 }
  38
  39 Path& Path::MakeRelative() {
  40   if (IsAbsolute()) {
  41     paths_.erase(paths_.begin());
  42   }
  43   return *this;
  44 }
  45
  46 Path& Path::Append(const Path& path) {
  47   // Appending an absolute path effectivly sets the path, ignoring
  48   // the current contents.
  49   if (path.IsAbsolute()) {
  50     paths_ = path.paths_;
  51   } else {
  52     for (size_t index = 0; index < path.paths_.size(); index++) {
  53       paths_.push_back(path.paths_[index]);
  54     }
  55   }
  56
  57   paths_ = Normalize(paths_);
  58   return *this;
  59 }
  60
  61 Path& Path::Append(const std::string& path) {
  62   return Append(Path(path));
  63 }
  64
  65 Path& Path::Set(const StringArray_t path) {
  66   paths_ = Normalize(path);
  67   return *this;
  68 }
  69
  70 Path& Path::Set(const std::string& path) {
  71   return Set(Split(path));
  72 }
  73
  74 Path Path::Parent() const {
  75   Path out;
  76   out.paths_ = paths_;
  77   if (out.paths_.size())
  78     out.paths_.pop_back();
  79   return out;
  80 }
  81
  82 std::string Path::Basename() const {
  83   if (paths_.size())
  84     return paths_.back();
  85   return std::string();
  86 }
  87
  88 std::string Path::Join() const {
  89   return Range(paths_, 0, paths_.size());
  90 }
  91
  92 std::string Path::Range(size_t start, size_t end) const {
  93   return Range(paths_, start, end);
  94 }
  95
  96 StringArray_t Path::Split() const {
  97   return paths_;
  98 }
  99
 100 // static
 101 StringArray_t Path::Normalize(const StringArray_t& paths) {
 102   StringArray_t path_out;
 103
 104   for (size_t index = 0; index < paths.size(); index++) {
 105     const std::string& curr = paths[index];
 106
 107     // Check if '/' was used excessively in the path.
 108     // For example, in cd Desktop/////
 109     if (curr == "/" && index != 0)
 110       continue;
 111
 112     // Check for '.' in the path and remove it
 113     if (curr == ".")
 114       continue;
 115
 116     // Check for '..'
 117     if (curr == "..") {
 118       // If the path is empty, or "..", then add ".."
 119       if (path_out.empty() || path_out.back() == "..") {
 120         path_out.push_back(curr);
 121         continue;
 122       }
 123
 124       // If the path is at root, "/.." = "/"
 125       if (path_out.back() == "/") {
 126         continue;
 127       }
 128
 129       // if we are already at root, then stay there (root/.. -> root)
 130       if (path_out.back() == "/") {
 131         continue;
 132       }
 133
 134       // otherwise, pop off the top path component
 135       path_out.pop_back();
 136       continue;
 137     }
 138
 139     // By now, we should have handled end cases so just append.
 140     path_out.push_back(curr);
 141   }
 142
 143   // If the path was valid, but now it's empty, return self
 144   if (path_out.empty())
 145     path_out.push_back(".");
 146
 147   return path_out;
 148 }
 149
 150 // static
 151 std::string Path::Join(const StringArray_t& paths) {
 152   return Range(paths, 0, paths.size());
 153 }
 154
 155 // static
 156 std::string Path::Range(const StringArray_t& paths, size_t start, size_t end) {
 157   std::string out_path;
 158   size_t index = start;
 159
 160   if (end > paths.size())
 161     end = paths.size();
 162
 163   // If this is an absolute path, paths[0] == "/". In this case, we don't want
 164   // to add an additional / separator.
 165   if (start == 0 && end > 0 && paths[0] == "/") {
 166     out_path += "/";
 167     index++;
 168   }
 169
 170   for (; index < end; index++) {
 171     out_path += paths[index];
 172     if (index < end - 1)
 173       out_path += "/";
 174   }
 175
 176   return out_path;
 177 }
 178
 179 // static
 180 StringArray_t Path::Split(const std::string& path) {
 181   StringArray_t path_split;
 182   StringArray_t components;
 183
 184   sdk_util::SplitString(path, '/', &path_split);
 185
 186   if (path[0] == '/')
 187     components.push_back("/");
 188
 189   // Copy path_split to components, removing empty path segments.
 190   for (StringArray_t::const_iterator it = path_split.begin();
 191        it != path_split.end();
 192        ++it) {
 193     if (!it->empty())
 194       components.push_back(*it);
 195   }
 196   return components;
 197 }
 198
 199 Path& Path::operator=(const Path& p) {
 200   paths_ = p.paths_;
 201   return *this;
 202 }
 203
 204 Path& Path::operator=(const std::string& p) {
 205   return Set(p);
 206 }
 207
 208 }  // namespace nacl_io