Path.hpp

/*
 * ------------------------------------------------------------------------------------------------------------
 * SPDX-License-Identifier: LGPL-2.1-only
 *
 * Copyright (c) 2018-2020 Lawrence Livermore National Security LLC
 * Copyright (c) 2018-2020 The Board of Trustees of the Leland Stanford Junior University
 * Copyright (c) 2018-2020 TotalEnergies
 * Copyright (c) 2019-     GEOSX Contributors
 * All rights reserved
 *
 * See top level LICENSE, COPYRIGHT, CONTRIBUTORS, NOTICE, and ACKNOWLEDGEMENTS files for details.
 * ------------------------------------------------------------------------------------------------------------
 */
 
#ifndef GEOS_COMMON_PATH_HPP
#define GEOS_COMMON_PATH_HPP
 
// System includes
#include <string>
#include <sstream>
#include <vector>
 
namespace geos
{
class Path : public std::string
{
public:
 
  using std::string::string;
 
  Path()
  {}
 
  Path( Path const & rhs ): std::string( rhs )
  {}
 
  Path( Path && rhs ) noexcept: std::string( std::move( rhs ) )
  {}
 
  Path & operator=( Path const & rhs )
  {
    std::string::operator=( rhs );
    return *this;
  }
 
  Path & operator=( Path && rhs ) noexcept
  {
    std::string::operator=( std::move( rhs ) );
    return *this;
  }
 
  ~Path()
  {}
 
  static void setPathPrefix( std::string_view p )
  {
    pathPrefix() = p;
  }
 
  static std::string_view getPathPrefix()
  {
    return pathPrefix();
  }
 
  std::string filename() const
  {
    size_type const pos = find_last_of( '/' );
    return pos == npos ? static_cast< std::string >( *this ) : substr( pos + 1 );
  }
 
  std::string extension() const
  {
    std::string const fname = filename();
    size_type const pos = fname.find_last_of( '.' );
    return pos == npos ? "" : fname.substr( pos + 1 );
  }
 
private:
 
  static std::string & pathPrefix()
  {
    static std::string s_pathPrefix = "";
    return s_pathPrefix;
  }
 
};
 
std::string getAbsolutePath( std::string const & path );
 
inline bool isAbsolutePath( std::string const & path )
{
  return !path.empty() && path[ 0 ] == '/';
}
 
std::istream & operator>>( std::istream & is, Path & p );
 
inline std::string trimPath( std::string const & path )
{
  return ( !path.empty() && path.back() == '/' ) ? path.substr( 0, path.size() - 1 ) : path;
}
 
std::pair< std::string, std::string > splitPath( std::string const & path );
 
template< typename ... ARGS >
std::string joinPath( ARGS const & ... args )
{
  size_t constexpr numParts = sizeof...(args);
  static_assert( numParts > 0, "Must provide arguments" );
  std::string parts[numParts] { trimPath( args ) ... };
  std::ostringstream oss;
  for( size_t i = 0; i < numParts - 1; ++i )
  {
    if( !parts[i].empty() )
    {
      oss << parts[i] << '/';
    }
  }
  oss << parts[numParts - 1];
  return oss.str();
}
 
std::vector< std::string > readDirectory( std::string const & path );
 
void makeDirectory( std::string const & path );
 
void makeDirsForPath( std::string const & path );
 
} /* end namespace geos */
 
 
#endif