ANSLibs/OpenVINO/runtime/include/openvino/frontend/frontend.hpp

// Copyright (C) 2018-2025 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
//

#pragma once

#include <filesystem>
#include <memory>
#include <string>
#include <vector>

#include "openvino/core/any.hpp"
#include "openvino/core/extension.hpp"
#include "openvino/core/model.hpp"
#include "openvino/core/op_extension.hpp"
#include "openvino/frontend/input_model.hpp"
#include "openvino/frontend/visibility.hpp"

namespace ov {
namespace frontend {
/// \brief An interface for identifying a frontend for a particular framework.
/// Provides an ability to load and convert of input model
class FRONTEND_API FrontEnd {
    friend class FrontEndManager;

    std::shared_ptr<void> m_shared_object = {};  // Library handle
    std::shared_ptr<FrontEnd> m_actual = {};

public:
    using Ptr = std::shared_ptr<FrontEnd>;

    /// \brief Default constructor
    FrontEnd();

    FrontEnd(const FrontEnd&) = delete;

    FrontEnd(FrontEnd&&) = delete;

    FrontEnd& operator=(const FrontEnd&) = delete;

    FrontEnd& operator=(FrontEnd&&) = delete;

    virtual ~FrontEnd();

    /// \brief Validates if FrontEnd can recognize model with parameters specified.
    /// Same parameters should be used to load model.
    /// \param vars Any number of parameters of any type. What kind of parameters
    /// are accepted is determined by each FrontEnd individually, typically it is
    /// std::string containing path to the model file. For more information please
    /// refer to specific FrontEnd documentation.
    /// \return true if model recognized, false - otherwise.
    template <typename... Types>
    inline bool supported(const Types&... vars) const {
        if constexpr ((std::is_same_v<std::filesystem::path, Types> || ...)) {
            return supported_impl({path_as_str_or_forward(vars)...});
        } else {
            return supported_impl({ov::Any(vars)...});
        }
    }
    inline bool supported(const ov::AnyVector& vars) const {
        return supported_impl(vars);
    }

    /// \brief Loads an input model by any specified arguments. Each FrontEnd separately
    /// defines what arguments it can accept.
    /// \param vars Any number of parameters of any type. What kind of parameters
    /// are accepted is determined by each FrontEnd individually, typically it is
    /// std::string containing path to the model file. For more information please
    /// refer to specific FrontEnd documentation.
    /// \return Loaded input model.
    template <typename... Types>
    inline InputModel::Ptr load(const Types&... vars) const {
        if constexpr ((std::is_same_v<std::filesystem::path, Types> || ...)) {
            return load_impl({path_as_str_or_forward(vars)...});
        } else {
            return load_impl({ov::Any{vars}...});
        }
    }

    inline InputModel::Ptr load(const ov::AnyVector& vars) const {
        return load_impl(vars);
    }

    /// \brief Completely convert and normalize entire Model, throws if it is not
    /// possible
    /// \param model Input model
    /// \return fully converted OV Model
    virtual std::shared_ptr<ov::Model> convert(const InputModel::Ptr& model) const;

    /// \brief Completely convert the remaining, not converted part of a Model.
    /// \param partiallyConverted partially converted OV Model
    virtual void convert(const std::shared_ptr<ov::Model>& partially_converted) const;

    /// \brief Convert only those parts of the model that can be converted leaving others
    /// as-is wrapped by FrameworkNode. Converted parts are normalized by additional
    /// transformations like it is done in convert method. If part of the graph cannot be
    /// converted, it is not guaranteed that the converted regions are completely normalized.
    /// Normalize should be called for each completely converted parts individually in this case.
    /// \param model Input model
    /// \return partially converted OV Model
    virtual std::shared_ptr<ov::Model> convert_partially(const InputModel::Ptr& model) const;

    /// \brief Convert operations with one-to-one mapping with decoding nodes.
    /// Each decoding node is an OV node representing a single FW operation node with
    /// all attributes represented in FW-independent way.
    /// \param model Input model
    /// \return OV Model after decoding
    virtual std::shared_ptr<ov::Model> decode(const InputModel::Ptr& model) const;

    /// \brief Runs normalization passes on Model that was loaded with partial conversion
    /// \param Model partially converted OV Model
    virtual void normalize(const std::shared_ptr<ov::Model>& model) const;

    /// \brief Gets name of this FrontEnd. Can be used by clients
    /// if frontend is selected automatically by FrontEndManager::load_by_model
    ///
    /// \return Current frontend name. Empty string if not implemented
    virtual std::string get_name() const;

    /// \brief Register base extension in the FrontEnd
    /// \param extension base extension
    virtual void add_extension(const std::shared_ptr<ov::Extension>& extension);

    /// \brief Register base extensions in the FrontEnd
    /// \param extensions vector of extensions
    void add_extension(const std::vector<std::shared_ptr<ov::Extension>>& extensions);

    /// \brief Registers extension
    /// \param library_path path to library with ov::Extension
    /// \{
    void add_extension(const std::string& library_path);

    void add_extension(const std::filesystem::path& library_path) {
        add_extension(library_path.string());
    }
    /// \}

#ifdef OPENVINO_ENABLE_UNICODE_PATH_SUPPORT

    /// \brief Registers extension
    /// \param library_path path to library with ov::Extension
    void add_extension(const std::wstring& library_path);

#endif

    /// @brief Registers extension
    /// @param extension Extension class which is inherited from ov::BaseOpExtension class
    template <class T, typename std::enable_if<std::is_base_of<ov::Extension, T>::value, bool>::type = true>
    void add_extension(const T& extension) {
        std::shared_ptr<ov::Extension> ext = std::make_shared<T>(extension);
        add_extension(ext);
    }

    /// @brief Registers extensions
    /// @param extension Extension class which is inherited from ov::Extension class
    template <class T,
              class... Targs,
              typename std::enable_if<std::is_base_of<ov::Extension, T>::value, bool>::type = true>
    void add_extension(const T& extension, Targs... args) {
        std::shared_ptr<ov::Extension> ext = std::make_shared<T>(extension);
        add_extension(ext);
        add_extension(args...);
    }

protected:
    virtual bool supported_impl(const std::vector<ov::Any>& variants) const;

    virtual InputModel::Ptr load_impl(const std::vector<ov::Any>& variants) const;

    void validate_path(const std::string& path) const;
#if defined(OPENVINO_ENABLE_UNICODE_PATH_SUPPORT) && defined(_WIN32)
    void validate_path(const std::wstring& path) const;
#endif

    std::vector<ov::Extension::Ptr> m_extensions;

private:
    static std::shared_ptr<ov::Model> create_copy(const std::shared_ptr<ov::Model>& ov_model,
                                                  const std::shared_ptr<void>& shared_object);

    template <class T>
    static constexpr auto path_as_str_or_forward(T&& p) {
        if constexpr (std::is_same_v<std::filesystem::path, std::decay_t<T>>) {
            return p.string();
        } else {
            return std::forward<T>(p);
        }
    }
};

template <>
inline bool FrontEnd::supported(const std::vector<ov::Any>& variants) const {
    return supported_impl(variants);
}

}  // namespace frontend

}  // namespace ov