Format.h File Reference

{fmt} formatter template specializations for API types. More...

#include <mvtec/plugin/mv_plugin_api_v2.h>
#include <mvtec/plugin-support/v1/Defines.h>
#include <mvtec/plugin-support/v1/Image.h>
#include <mvtec/plugin-support/v1/detail/VisitorOverloaded.h>
#include <fmt/chrono.h>
#include <fmt/format.h>
#include <fmt/ranges.h>
#include <algorithm>
#include <string_view>
#include <type_traits>
#include <utility>

Data Structures
struct	formatter< MVPlugin::VariantScalar >
struct	formatter< MVPlugin::VariantArray >
struct	formatter< MVPlugin::Value >
struct	formatter< MVPlugin::ImageDimensions >
struct	formatter< MVPlugin::OptionsPNG >
struct	formatter< MVPlugin::OptionsJPEG >
struct	formatter< MVPlugin::OptionsHSerializedItem >
struct	formatter< MVPlugin::ImageTypeOptions >
struct	formatter< MVPlugin::ImagePNG >
struct	formatter< MVPlugin::ImageJPEG >
struct	formatter< MVPlugin::HSerializedItem >
struct	formatter< MVPlugin::DataComponentError >
struct	formatter< MVPlugin::DataComponentPayload >
struct	formatter< MVPlugin::Error >
struct	formatter< MVPlugin::RecipeParam >
struct	formatter< MVPlugin::DataInfo >
struct	formatter< MVPlugin::RecipeData >
struct	formatter< MVPlugin::ActionInfo >
struct	formatter< MVPlugin::JobInfo >
struct	formatter< MVPlugin::AcquisitionInfo >

Macros
#define	MVPLUGIN_ENUM_FMT_FORMATTER(ENUM_TYPE, ...)
#define	MVPLUGIN_OPTIONAL_FMT_FORMATTER(OPTIONAL_TYPE)

Functions
	MVPLUGIN_ENUM_FMT_FORMATTER (MVPlugin::State, {{MVPlugin::State::Null, "<unknown-state>"}, {MVPlugin::State::Preoperational, "Preoperational"}, {MVPlugin::State::Halted, "Halted"}, {MVPlugin::State::Error, "Error"}, {MVPlugin::State::Initialized, "Initialized"}, {MVPlugin::State::Ready, "Ready"}, {MVPlugin::State::SingleExecution, "SingleExecution"}, {MVPlugin::State::ContinuousExecution, "ContinuousExecution"}, {MVPlugin::State::FrontendAccess, "FrontendAccess"}}) MVPLUGIN_ENUM_FMT_FORMATTER(MVPlugin
	MVPLUGIN_ENUM_FMT_FORMATTER (MVPlugin::DataType, {{MVPlugin::DataType::Null, "<unknown-data-type>"}, {MVPlugin::DataType::Bool, "Bool"}, {MVPlugin::DataType::Int8, "Int8"}, {MVPlugin::DataType::UInt8, "UInt8"}, {MVPlugin::DataType::Int16, "Int16"}, {MVPlugin::DataType::UInt16, "UInt16"}, {MVPlugin::DataType::Int32, "Int32"}, {MVPlugin::DataType::UInt32, "UInt32"}, {MVPlugin::DataType::Int64, "Int64"}, {MVPlugin::DataType::UInt64, "UInt64"}, {MVPlugin::DataType::Float, "Float"}, {MVPlugin::DataType::Double, "Double"}, {MVPlugin::DataType::String, "String"}, {MVPlugin::DataType::Variant, "Variant"}}) MVPLUGIN_ENUM_FMT_FORMATTER(MVPlugin
	MVPLUGIN_ENUM_FMT_FORMATTER (MVPlugin::ActionType, {{MVPlugin::ActionType::Null, "<unknown-action-type>"}, {MVPlugin::ActionType::SelectMode, "SelectMode"}, {MVPlugin::ActionType::PrepareRecipe, "PrepareRecipe"}, {MVPlugin::ActionType::UnprepareRecipe, "UnprepareRecipe"}, {MVPlugin::ActionType::StartSingleJob, "StartSingleJob"}, {MVPlugin::ActionType::StartContinuous, "StartContinuous"}, {MVPlugin::ActionType::Halt, "Halt"}, {MVPlugin::ActionType::Reset, "Reset"}, {MVPlugin::ActionType::Stop, "Stop"}, {MVPlugin::ActionType::Abort, "Abort"}}) MVPLUGIN_ENUM_FMT_FORMATTER(MVPlugin
	MVPLUGIN_ENUM_FMT_FORMATTER (MVPlugin::Severity, {{MVPlugin::Severity::Null, "<unknown-severity>"}, {MVPlugin::Severity::Warning, "Warning"}, {MVPlugin::Severity::Error, "Error"}, {MVPlugin::Severity::Critical, "Critical"}}) MVPLUGIN_ENUM_FMT_FORMATTER(MVPlugin
	MVPLUGIN_ENUM_FMT_FORMATTER (MVEventType_t, {{eMVEvent_Null, "eMVEvent_Null"}, {eMVEvent_StateChanged, "eMVEvent_StateChanged"}, {eMVEvent_RecipePrepared, "eMVEvent_RecipePrepared"}, {eMVEvent_RecipeUnprepared, "eMVEvent_RecipeUnprepared"}, {eMVEvent_ResultReady, "eMVEvent_ResultReady"}, {eMVEvent_Ready, "eMVEvent_Ready"}, {eMVEvent_JobStarted, "eMVEvent_JobStarted"}, {eMVEvent_Error, "eMVEvent_Error"}, {eMVEvent_AcquisitionDone, "eMVEvent_AcquisitionDone"}, {eMVEvent_Shutdown, "eMVEvent_Shutdown"}, {eMVEvent_Force32, "eMVEvent_Force32"}}) MVPLUGIN_ENUM_FMT_FORMATTER(MVPlugin

Detailed Description

{fmt} formatter template specializations for API types.

Note that this file should only be included if the optional {fmt} dependency is available and the MV_USE_FMT macro is defined.

Macro Definition Documentation

MVPLUGIN_ENUM_FMT_FORMATTER

#define MVPLUGIN_ENUM_FMT_FORMATTER	(		ENUM_TYPE,
			...
	)

Value:

  template<> struct fmt::formatter<ENUM_TYPE> : fmt::formatter<std::string_view>                                                                         \
  {                                                                                                                                                      \
    auto format(ENUM_TYPE enum_value, format_context& ctx) const -> format_context::iterator                                                             \
    {                                                                                                                                                    \
      return fmt::formatter<std::string_view>::format(                                                                                                   \
          [enum_value] {                                                                                                                                 \
            static_assert(std::is_enum<ENUM_TYPE>::value, #ENUM_TYPE " must be an enum!");                                                               \
            constexpr std::pair<ENUM_TYPE, const char*> m[] = __VA_ARGS__;                                                                               \
            auto                                        it  = std::find_if(std::begin(m), std::end(m),                                                   \
                                                                           [enum_value](const std::pair<ENUM_TYPE, const char*>& estring_pair) -> bool { \
                                     return estring_pair.first == enum_value;                                    \
                                   });                                                                           \
            return ((it != std::end(m)) ? it : std::begin(m))->second;                                                                                   \
          }(),                                                                                                                                           \
          ctx);                                                                                                                                          \
    }                                                                                                                                                    \
  };

MVPLUGIN_OPTIONAL_FMT_FORMATTER

#define MVPLUGIN_OPTIONAL_FMT_FORMATTER

(

OPTIONAL_TYPE

)

Value:

  template<> struct fmt::formatter<std::optional<OPTIONAL_TYPE>> : fmt::formatter<OPTIONAL_TYPE>                            \
  {                                                                                                                         \
    auto format(std::optional<OPTIONAL_TYPE> const& val, format_context& ctx) const -> format_context::iterator             \
    {                                                                                                                       \
      if (val.has_value())                                                                                                  \
        return fmt::formatter<OPTIONAL_TYPE>::format(*val, ctx);                                                            \
      else                                                                                                                  \
        return fmt::format_to(ctx.out(), "<nullopt>");                                                                      \
    }                                                                                                                       \
  };