Add FilePath::FinalExtension and RemoveFinalExtension

base/files/file_path.cc

 // Copyright 2008 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "base/files/file_path.h"
 
 #include <ctype.h>
 
 #include "base/basictypes.h"
 #include "base/logging.h"
 
 namespace base {
 
 #if defined(FILE_PATH_USES_WIN_SEPARATORS)
 const FilePath::CharType FilePath::kSeparators[] = FILE_PATH_LITERAL("\\/");
 #else  // FILE_PATH_USES_WIN_SEPARATORS
 const FilePath::CharType FilePath::kSeparators[] = FILE_PATH_LITERAL("/");
 #endif  // FILE_PATH_USES_WIN_SEPARATORS
 
 const FilePath::CharType FilePath::kCurrentDirectory[] = FILE_PATH_LITERAL(".");
+const FilePath::CharType FilePath::kParentDirectory[] = FILE_PATH_LITERAL("..");
+const FilePath::CharType FilePath::kExtensionSeparator = FILE_PATH_LITERAL('.');
 
 typedef FilePath::StringType StringType;
 
 namespace {
 
 const FilePath::CharType kStringTerminator = FILE_PATH_LITERAL('\0');
 
 // If this FilePath contains a drive letter specification, returns the
 // position of the last character of the drive letter specification,
 // otherwise returns npos.  This can only be true on Windows, when a pathname
@@ skipping 40 matching lines @@
   }
   // Look for a pair of leading separators.
   return path.length() > 1 &&
       FilePath::IsSeparator(path[0]) && FilePath::IsSeparator(path[1]);
 #else  // FILE_PATH_USES_DRIVE_LETTERS
   // Look for a separator in the first position.
   return path.length() > 0 && FilePath::IsSeparator(path[0]);
 #endif  // FILE_PATH_USES_DRIVE_LETTERS
 }
 
+// Find the position of the '.' that separates the extension from the rest
+// of the file name. The position is relative to BaseName(), not value().

[Mark Mentovai, 2015/01/20 17:11:53]

The second sentence should be harsher: this function requires that its path
argument be a basename, not a full path.

[scottmg, 2015/01/20 18:01:27]

After simplifying below, just deleted this function.

+// Returns npos if it can't find an extension.
+StringType::size_type FinalExtensionSeparatorPosition(const StringType& path) {
+  // Special case "." and ".."
+  if (path == FilePath::kCurrentDirectory || path == FilePath::kParentDirectory)
+    return StringType::npos;
+
+  return path.rfind(FilePath::kExtensionSeparator);
+}
+
 }  // namespace
 
 FilePath::FilePath() {
 }
 
 FilePath::FilePath(const FilePath& that) : path_(that.path_) {
 }
 
 FilePath::FilePath(const StringType& path) : path_(path) {
   StringType::size_type nul_pos = path_.find(kStringTerminator);
@@ skipping 92 matching lines @@
       new_path.path_.find_last_of(kSeparators, StringType::npos,
                                   arraysize(kSeparators) - 1);
   if (last_separator != StringType::npos &&
       last_separator < new_path.path_.length() - 1) {
     new_path.path_.erase(0, last_separator + 1);
   }
 
   return new_path;
 }
 
+StringType FilePath::FinalExtension() const {
+  FilePath base(BaseName());
+  const StringType::size_type dot = FinalExtensionSeparatorPosition(base.path_);
+  if (dot == StringType::npos)
+    return StringType();
+
+  return base.path_.substr(dot, StringType::npos);
+}
+
+FilePath FilePath::RemoveFinalExtension() const {
+  if (FinalExtension().empty())
+    return *this;
+
+  const StringType::size_type dot = FinalExtensionSeparatorPosition(path_);

[Mark Mentovai, 2015/01/20 17:11:53]

This logic winds up calling FinalExtension() twice, which doesn’t seem
necessary. Why not call it once and then lop off the extension based on its
length?

[scottmg, 2015/01/20 18:01:27]

Done.

+  if (dot == StringType::npos)
+    return *this;
+
+  return FilePath(path_.substr(0, dot));
+}
+
 FilePath FilePath::Append(const StringType& component) const {
   const StringType* appended = &component;
   StringType without_nuls;
 
   StringType::size_type nul_pos = component.find(kStringTerminator);
   if (nul_pos != StringType::npos) {
     without_nuls = component.substr(0, nul_pos);
     appended = &without_nuls;
   }
 
@@ skipping 59 matching lines @@
       last_stripped = pos;
     }
   }
 }
 
 }  // namespace base
 
 void PrintTo(const base::FilePath& path, std::ostream* out) {
   *out << path.value().c_str();
 }