[core] Migrate some file utils use fs path (#32882)

### Details:
 Migrate file utils to use std path class:
  - file_exists
  - make_plugin_library_name
  - get_plugin_path
  - get_compiled_plugin_path
  
Remove not used/required utils functions
 - remove is_absolute_file_path
 - remove to_file_path

### Tickets:
 - CVS-176714

---------

Signed-off-by: Pawel Raasz <pawel.raasz@intel.com>

Author: praasz

src/bindings/c/tests/test_model_repo.cpp

@@ -41,8 +41,7 @@ std::string generate_test_xml_file() {
     plugin_xml_file << ov::util::FileTraits<char>::library_prefix();
     plugin_xml_file << "mock_engine";
     plugin_xml_file << OV_BUILD_POSTFIX;
-    plugin_xml_file << ov::util::FileTraits<char>::dot_symbol;
-    plugin_xml_file << ov::util::FileTraits<char>::library_ext();
+    plugin_xml_file << ov::util::library_extension().string();
     plugin_xml_file << "\" name=\"CUSTOM\">\n";
     plugin_xml_file << "        </plugin>\n";
     plugin_xml_file << "    </plugins>\n";

src/common/util/include/openvino/util/file_util.hpp

@@ -80,13 +80,50 @@ struct FileTraits<wchar_t> {
     }
 };
 
+inline std::filesystem::path library_prefix() {
+#if defined(_WIN32) && (defined(__MINGW32__) || defined(__MINGW64__))
+    return {"lib"};
+#elif defined(_WIN32)
+    return {};
+#else
+    return {"lib"};
+#endif
+}
+inline std::filesystem::path library_extension() {
+#ifdef _WIN32
+    return {".dll"};
+#else
+    return {".so"};
+#endif
+}
+
+/**
+ * @brief Creates std::filesystem::path provided by source.
+ *
+ * The purpose of this function is to hide platform specific issue with path creation like on Windows create from
+ * literal std::string with unicode characters can lead to different path name than expected.
+ *
+ * @param source  Source to create path. Supported types are same as for std::filesystem::path constructor.
+ * @return std::filesystem::path object.
+ */
+template <class Source>
+std::filesystem::path make_path(Source&& source) {
+    if constexpr (std::is_same_v<std::add_const_t<std::remove_pointer_t<std::decay_t<Source>>>, const wchar_t>) {
+        return {std::wstring(std::forward<Source>(source))};
+    } else if constexpr (std::is_same_v<std::filesystem::path::string_type, std::wstring> &&
+                         std::is_same_v<std::decay_t<Source>, std::string>) {
+        return {ov::util::string_to_wstring(std::forward<Source>(source))};
+    } else {
+        return {std::forward<Source>(source)};
+    }
+}
+
 /**
  * @brief Convert path as char string to to a single-byte chain.
  * @param path Path as char string.
  * @return Reference to input path (no conversion).
  */
-template <class Path,
-          typename std::enable_if<std::is_same<typename std::decay<Path>::type, std::string>::value>::type* = nullptr>
+template <class Path, typename std::enable_if_t<std::is_same_v<std::decay_t<Path>, std::string>>* = nullptr>
 const std::string& path_to_string(const Path& path) {
     return path;
 }
@@ -97,14 +134,23 @@ const std::string& path_to_string(const Path& path) {
  * @param path  Path as wide-char string.
  * @return A char string
  */
-template <class Path,
-          typename std::enable_if<std::is_same<typename std::decay<Path>::type, std::wstring>::value>::type* = nullptr>
+template <class Path, typename std::enable_if_t<std::is_same_v<std::decay_t<Path>, std::wstring>>* = nullptr>
 std::string path_to_string(const Path& path) {
     return ov::util::wstring_to_string(path);
 }
 
 #endif
 
+/**
+ * @brief Convert std::filesystem::path single-byte chain.
+ * Function resolve issue when path create from std::string which contains unicode characters.
+ * @param path  Path.
+ * @return A char string.
+ */
+inline auto path_to_string(const std::filesystem::path& path) -> decltype(path_to_string(path.native())) {
+    return ov::util::path_to_string(path.native());
+}
+
 /// \brief Remove path components which would allow traversing up a directory tree.
 /// \param path A path to file
 /// \return A sanitized path
@@ -122,14 +168,6 @@ std::string get_file_name(const std::string& path);
  */
 std::string get_absolute_file_path(const std::string& path);
 
-/**
- * @brief Interface function to check path to file is absolute or not
- * @param path - path to file, can be relative to current working directory
- * @return True if path is absolute and False otherwise
- * @throw runtime_error if any error occurred
- */
-bool is_absolute_file_path(const std::string& path);
-
 /**
  * @brief Interface function to create directories recursively by given path
  * @param path - path to file, can be relative to current working directory
@@ -172,47 +210,27 @@ inline int64_t file_size(const char* path) {
 #endif
 
 /**
- * @brief      Returns file size for file
- * @param[in]  path  The file name
- * @return     file size
+ * @brief      Tests whether file exists at given path.
+ * @param[in]  path  The file path.
+ * @return     True if file exists, false otherwise.
+ * @{
  */
-inline bool file_exists(const char* path) {
-#if defined(OPENVINO_ENABLE_UNICODE_PATH_SUPPORT) && defined(_WIN32)
-    std::wstring widefilename = ov::util::string_to_wstring(path);
-    const wchar_t* file_name = widefilename.c_str();
-#elif defined(__ANDROID__) || defined(ANDROID)
-    std::string file_name = path;
-    std::string::size_type pos = file_name.find('!');
-    if (pos != std::string::npos) {
-        file_name = file_name.substr(0, pos);
-    }
+inline bool file_exists(const std::filesystem::path& path) noexcept {
+#if defined(__ANDROID__) || defined(ANDROID)
+    const auto pos = path.native().find('!');
+    const auto f_status = (pos == std::string::npos) ? std::filesystem::status(path)
+                                                     : std::filesystem::status(path.native().substr(0, pos));
 #else
-    const char* file_name = path;
+    const auto f_status = std::filesystem::status(path);
 #endif
-    std::ifstream in(file_name, std::ios_base::binary | std::ios_base::ate);
-    return in.good();
+    return std::filesystem::exists(f_status) && !std::filesystem::is_directory(f_status);
 }
 
-#ifdef OPENVINO_ENABLE_UNICODE_PATH_SUPPORT
-
-/**
- * @brief      Returns true if file exists
- * @param[in]  path  The file name
- * @return     true if file exists
- */
-inline bool file_exists(const std::wstring& path) {
-    return file_exists(wstring_to_string(path).c_str());
-}
-#endif  // OPENVINO_ENABLE_UNICODE_PATH_SUPPORT
-
-/**
- * @brief      Returns true if file exists
- * @param[in]  path  The file name
- * @return     true if file exists
- */
-inline bool file_exists(const std::string& path) {
-    return file_exists(path.c_str());
+template <class T>
+inline bool file_exists(const std::basic_string<T>& path) noexcept {
+    return file_exists(make_path(path));
 }
+/** @} */
 
 std::string get_file_ext(const std::string& path);
 std::filesystem::path get_directory(const std::filesystem::path& path);
@@ -236,16 +254,6 @@ using FilePath = std::filesystem::path::string_type;
 inline std::string from_file_path(const std::filesystem::path& path) {
     return path.string();
 }
-
-// TODO: remove this function after all calls use Path
-inline FilePath to_file_path(const std::filesystem::path& path) {
-#if defined(_WIN32) && defined(OPENVINO_ENABLE_UNICODE_PATH_SUPPORT)
-    return ov::util::string_to_wstring(path.string());
-#else
-    return path.native();
-#endif
-}
-
 #ifdef OPENVINO_ENABLE_UNICODE_PATH_SUPPORT
 
 /**
@@ -277,22 +285,31 @@ inline std::basic_string<C> make_plugin_library_name(const std::basic_string<C>&
            FileTraits<C>::library_ext();
 }
 
+inline std::filesystem::path make_plugin_library_name(const std::filesystem::path& lib_name) {
+    return library_prefix().concat(lib_name.filename().native()).concat(library_extension().native());
+}
+
+inline std::filesystem::path make_plugin_library_name(const std::filesystem::path& dir_path,
+                                                      const std::filesystem::path& lib_name) {
+    return dir_path / make_plugin_library_name(lib_name);
+}
+
 /**
  * @brief Format plugin path (canonicalize, complete to absolute or complete to file name) for further
  * dynamic loading by OS
  * @param plugin - Path (absolute or relative) or name of a plugin. Depending on platform, `plugin` is wrapped with
  * shared library suffix and prefix to identify library full name
  * @return absolute path or file name with extension (to be found in ENV)
  */
-FilePath get_plugin_path(const std::string& plugin);
+std::filesystem::path get_plugin_path(const std::filesystem::path& plugin);
 
 /**
  * @brief Find the plugins which are located together with OV library
  * @param plugin - Path (absolute or relative) or name of a plugin. Depending on platform, `plugin` is wrapped with
  * shared library suffix and prefix to identify library full name
  * @return absolute path or file name with extension (to be found in ENV)
  */
-FilePath get_compiled_plugin_path(const std::string& plugin);
+std::filesystem::path get_compiled_plugin_path(const std::filesystem::path& plugin);
 
 /**
  * @brief Format plugin path (canonicalize, complete to absolute or complete to file name) for further
@@ -303,7 +320,9 @@ FilePath get_compiled_plugin_path(const std::string& plugin);
  * @param as_abs_only - Bool value, allows return file names or not
  * @return absolute path or file name with extension (to be found in ENV)
  */
-FilePath get_plugin_path(const std::string& plugin, const std::string& xml_path, bool as_abs_only = false);
+std::filesystem::path get_plugin_path(const std::filesystem::path& plugin,
+                                      const std::filesystem::path& xml_path,
+                                      bool as_abs_only = false);
 
 /**
  * @brief load binary data from file
@@ -345,27 +364,5 @@ inline std::basic_string<C> make_path(const std::basic_string<C>& folder, const
         return file;
     return folder + ov::util::FileTraits<C>::file_separator + file;
 }
-
-/**
- * @brief Creates std::filesystem::path provided by source.
- *
- * The purpose of this function is to hide platform specific issue with path creation like on Windows create from
- * literal std::string with unicode characters can lead to different path name than expected.
- *
- * @param source  Source to create path. Supported types are same as for std::filesystem::path constructor.
- * @return std::filesystem::path object.
- */
-template <class Source>
-std::filesystem::path make_path(const Source& source) {
-    if constexpr (std::is_same_v<std::decay_t<Source>, wchar_t*>) {
-        return {std::wstring(source)};
-    } else if constexpr (std::is_same_v<std::filesystem::path::value_type, std::wstring::value_type> &&
-                         std::is_same_v<Source, std::string>) {
-        return {ov::util::string_to_wstring(source)};
-    } else {
-        return {source};
-    }
-}
-
 }  // namespace util
 }  // namespace ov