path.hpp

Go to the documentation of this file.

 
#pragma once
#include "file.hpp"
#include "../core_export.hpp"
#include "../static.hpp"
#include "../string.hpp"
#include <algorithm>
#include <cstdlib>
#include <random>
#include <regex>
#include <sstream>
 
//#include <iostream>
 
namespace xtd {
  namespace io {
    class core_export_ path static_ {
    public:
      
      template<typename char_t>
      static char_t alt_directory_separator_char() noexcept {return static_cast<char_t>(alt_directory_separator_char());}
      
      static char alt_directory_separator_char() noexcept;
      
      template<typename char_t>
      static char_t directory_separator_char() noexcept {
        return static_cast<char_t>(directory_separator_char());
      }
      
      static char directory_separator_char() noexcept;
      
      template<typename char_t>
      static char_t path_separator() noexcept {return static_cast<char_t>(path_separator());}
      
      static char path_separator() noexcept;
      
      template<typename char_t>
      static char_t volume_separator_char() noexcept {return  static_cast<char_t>(volume_separator_char());}
      
      static char volume_separator_char() noexcept;
      
      
      static xtd::string change_extension(const xtd::string& path, const xtd::string& extension);
      
      static xtd::string combine(const xtd::string& path1, const xtd::string& path2);
      
      template<typename type1_t, typename type2_t, typename type3_t>
      static auto combine(type1_t path1, type2_t path2, type3_t path3) noexcept {
        return combine(combine(path1, path2), path3);
      }
      
      template<typename type1_t, typename type2_t, typename type3_t, typename type4_t>
      static auto combine(type1_t path1, type2_t path2, type3_t path3, type4_t path4) noexcept {
        return combine(combine(combine(path1, path2), path3), path4);
      }
      
      template<typename path_t>
      static xtd::string combine(path_t paths) noexcept {
        xtd::string result;
        std::for_each(paths.begin(), paths.end(), [&](auto path) {result = combine(result, path);});
        return result;
      }
      
      static xtd::string combine(const std::initializer_list<xtd::string>& paths) noexcept;
      
      static xtd::string get_directory_name(const xtd::string& path);
      
      static xtd::string get_extension(const xtd::string& path);
      
      static xtd::string get_file_name(const xtd::string& path);
 
      static xtd::string get_file_name_without_extension(const xtd::string& path);
      
      static xtd::string get_full_path(const xtd::string& path);
      
      template<typename char_t>
      static std::vector<char_t> get_invalid_path_chars() noexcept {return {34, 60, 62, 124, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 0};}
      
      static std::vector<char> get_invalid_path_chars() noexcept;
      
      static xtd::string get_path_root(const xtd::string& path);
      
      static xtd::string get_random_file_name();
      static xtd::string get_random_file_name(size_t name_length);
      static xtd::string get_random_file_name(size_t name_size, size_t extension_size);
 
      static xtd::string get_temp_file_name();
 
      static xtd::string get_temp_path() noexcept;
      
      static bool has_extension(const xtd::string& path);
      
      static bool is_path_rooted(const xtd::string& path);
      
    private:
      static int32 __get_index_path_rooted(const xtd::string& path);
      static bool __is_drive(const xtd::string& path) noexcept;
    };
  }
}