class ov::AttributeAdapter<ov::op::util::FrameworkNodeAttrs>

#include <framework_node.hpp>

template <>
class AttributeAdapter<ov::op::util::FrameworkNodeAttrs>: public ov::DirectValueAccessor
{
public:
    // construction

    AttributeAdapter(ov::op::util::FrameworkNodeAttrs& value);

    // methods

    OPENVINO_RTTI("AttributeAdapter<FrameworkNodeAttr>");
};

Inherited Members

public:
    // methods

    virtual const VAT& get() = 0;
    virtual void set(const VAT& value) = 0;
    void set_as_any(const ov::Any& x);
    virtual const AT& get();
    virtual void set(const AT& value);

class ov::AttributeAdapter<ov::NodeVector>

#include <node.hpp>

template <>
class AttributeAdapter<ov::NodeVector>: public ov::VisitorAdapter
{
public:
    // construction

    AttributeAdapter(ov::NodeVector& ref);

    // methods

    virtual bool visit_attributes(AttributeVisitor& visitor);
    OPENVINO_RTTI("AttributeAdapter<NodeVector>");
};

Inherited Members

public:
    // methods

    virtual const DiscreteTypeInfo& get_type_info() const = 0;
    virtual void set_as_any(const ov::Any& x);
    virtual bool visit_attributes(AttributeVisitor& visitor) = 0;

class ov::AttributeAdapter<ov::PartialShape>

#include <partial_shape.hpp>

template <>
class AttributeAdapter<ov::PartialShape>: public ov::DirectValueAccessor
{
public:
    // construction

    AttributeAdapter(ov::PartialShape& value);

    // methods

    OPENVINO_RTTI("AttributeAdapter<PartialShape>");
};

Inherited Members

public:
    // methods

    virtual const VAT& get() = 0;
    virtual void set(const VAT& value) = 0;
    void set_as_any(const ov::Any& x);
    virtual const AT& get();
    virtual void set(const AT& value);

class ov::AttributeAdapter<ov::Shape>

#include <shape.hpp>

template <>
class AttributeAdapter<ov::Shape>: public ov::IndirectVectorValueAccessor
{
public:
    // construction

    AttributeAdapter(ov::Shape& value);

    // methods

    OPENVINO_RTTI("AttributeAdapter<Shape>");
};

Inherited Members

public:
    // methods

    virtual const VAT& get() = 0;
    virtual void set(const VAT& value) = 0;
    void set_as_any(const ov::Any& x);
    virtual const VAT& get();
    virtual void set(const VAT& value);
    void set_as_any(const ov::Any& x);
    operator AT & ();

class ov::AttributeAdapter<ParameterVector>

#include <parameter.hpp>

template <>
class AttributeAdapter<ParameterVector>: public ov::VisitorAdapter
{
public:
    // construction

    AttributeAdapter(ParameterVector& ref);

    // methods

    virtual bool visit_attributes(AttributeVisitor& visitor);
    OPENVINO_RTTI("AttributeAdapter<ParameterVector>");
};

Inherited Members

public:
    // methods

    virtual const DiscreteTypeInfo& get_type_info() const = 0;
    virtual void set_as_any(const ov::Any& x);
    virtual bool visit_attributes(AttributeVisitor& visitor) = 0;

class ov::AttributeAdapter<ResultVector>

#include <result.hpp>

template <>
class AttributeAdapter<ResultVector>: public ov::VisitorAdapter
{
public:
    // construction

    AttributeAdapter(ResultVector& ref);

    // methods

    virtual bool visit_attributes(AttributeVisitor& visitor);
    OPENVINO_RTTI("AttributeAdapter<ResultVector>");
};

Inherited Members

public:
    // methods

    virtual const DiscreteTypeInfo& get_type_info() const = 0;
    virtual void set_as_any(const ov::Any& x);
    virtual bool visit_attributes(AttributeVisitor& visitor) = 0;

class ov::AttributeAdapter<ov::element::TypeVector>

#include <element_type.hpp>

template <>
class AttributeAdapter<ov::element::TypeVector>: public ov::DirectValueAccessor
{
public:
    // construction

    AttributeAdapter(ov::element::TypeVector& value);

    // methods

    OPENVINO_RTTI("AttributeAdapter<ov::element::TypeVector>");
};

Inherited Members

public:
    // methods

    virtual const VAT& get() = 0;
    virtual void set(const VAT& value) = 0;
    void set_as_any(const ov::Any& x);
    virtual const AT& get();
    virtual void set(const AT& value);

class ov::AttributeAdapter<std::set<std::string>>

#include <attribute_adapter.hpp>

template <>
class AttributeAdapter<std::set<std::string>>: public ov::DirectValueAccessor
{
public:
    // construction

    AttributeAdapter(std::set<std::string>& value);

    // methods

    OPENVINO_RTTI("AttributeAdapter<set<string>>");
};

Inherited Members

public:
    // methods

    virtual const VAT& get() = 0;
    virtual void set(const VAT& value) = 0;
    void set_as_any(const ov::Any& x);
    virtual const AT& get();
    virtual void set(const AT& value);

class ov::AttributeAdapter<ov::element::Type_t>

#include <element_type.hpp>

template <>
class AttributeAdapter<ov::element::Type_t>: public ov::EnumAttributeAdapterBase
{
public:
    // construction

    AttributeAdapter(ov::element::Type_t& value);

    // methods

    OPENVINO_RTTI("AttributeAdapter<ov::element::Type_t>");
};

Inherited Members

public:
    // methods

    virtual const VAT& get() = 0;
    virtual void set(const VAT& value) = 0;
    void set_as_any(const ov::Any& x);
    virtual const std::string& get();
    virtual void set(const std::string& value);
    operator AT & ();
    void set_as_any(const ov::Any& x);

class ov::AttributeAdapter<ov::element::Type>

Overview

#include <element_type.hpp>

template <>
class AttributeAdapter<ov::element::Type>: public ov::ValueAccessor
{
public:
    // construction

    AttributeAdapter(ov::element::Type& value);

    // methods

    OPENVINO_RTTI("AttributeAdapter<ov::element::Type>");
    virtual const std::string& get();
    virtual void set(const std::string& value);
    operator ov::element::Type & ();
};

Inherited Members

public:
    // methods

    virtual const VAT& get() = 0;
    virtual void set(const VAT& value) = 0;
    void set_as_any(const ov::Any& x);

Methods

virtual const std::string& get()

Returns the value.

virtual void set(const std::string& value)

Sets the value.

class ov::AttributeAdapter<ov::Dimension>

#include <dimension.hpp>

template <>
class AttributeAdapter<ov::Dimension>: public ov::DirectValueAccessor
{
public:
    // construction

    AttributeAdapter(ov::Dimension& value);

    // methods

    OPENVINO_RTTI("AttributeAdapter<ov::Dimension>");
};

Inherited Members

public:
    // methods

    virtual const VAT& get() = 0;
    virtual void set(const VAT& value) = 0;
    void set_as_any(const ov::Any& x);
    virtual const AT& get();
    virtual void set(const AT& value);

class ov::AttributeAdapter<op::v9::GridSample::PaddingMode>

#include <grid_sample.hpp>

template <>
class AttributeAdapter<op::v9::GridSample::PaddingMode>: public ov::EnumAttributeAdapterBase
{
public:
    // construction

    AttributeAdapter(op::v9::GridSample::PaddingMode& value);

    // methods

    OPENVINO_RTTI("AttributeAdapter<ov::op::v9::GridSample::PaddingMode>");
};

Inherited Members

public:
    // methods

    virtual const VAT& get() = 0;
    virtual void set(const VAT& value) = 0;
    void set_as_any(const ov::Any& x);
    virtual const std::string& get();
    virtual void set(const std::string& value);
    operator AT & ();
    void set_as_any(const ov::Any& x);

class ov::AttributeAdapter<op::v9::GridSample::InterpolationMode>

#include <grid_sample.hpp>

template <>
class AttributeAdapter<op::v9::GridSample::InterpolationMode>: public ov::EnumAttributeAdapterBase
{
public:
    // construction

    AttributeAdapter(op::v9::GridSample::InterpolationMode& value);

    // methods

    OPENVINO_RTTI("AttributeAdapter<ov::op::v9::GridSample::InterpolationMode>");
};

Inherited Members

public:
    // methods

    virtual const VAT& get() = 0;
    virtual void set(const VAT& value) = 0;
    void set_as_any(const ov::Any& x);
    virtual const std::string& get();
    virtual void set(const std::string& value);
    operator AT & ();
    void set_as_any(const ov::Any& x);

class ov::AttributeAdapter<op::v8::MatrixNms::SortResultType>

#include <matrix_nms.hpp>

template <>
class AttributeAdapter<op::v8::MatrixNms::SortResultType>: public ov::EnumAttributeAdapterBase
{
public:
    // construction

    AttributeAdapter(op::v8::MatrixNms::SortResultType& value);

    // methods

    OPENVINO_RTTI("AttributeAdapter<ov::op::v8::MatrixNms::SortResultType>");
};

Inherited Members

public:
    // methods

    virtual const VAT& get() = 0;
    virtual void set(const VAT& value) = 0;
    void set_as_any(const ov::Any& x);
    virtual const std::string& get();
    virtual void set(const std::string& value);
    operator AT & ();
    void set_as_any(const ov::Any& x);

class ov::AttributeAdapter<std::shared_ptr<ngraph::runtime::AlignedBuffer>>

#include <aligned_buffer.hpp>

template <>
class AttributeAdapter<std::shared_ptr<ngraph::runtime::AlignedBuffer>>: public ov::DirectValueAccessor
{
public:
    // construction

    AttributeAdapter(std::shared_ptr<ngraph::runtime::AlignedBuffer>& value);

    // methods

    OPENVINO_RTTI();
};

Inherited Members

public:
    // methods

    virtual const VAT& get() = 0;
    virtual void set(const VAT& value) = 0;
    void set_as_any(const ov::Any& x);
    virtual const AT& get();
    virtual void set(const AT& value);

class ov::AttributeAdapter<op::v9::NonMaxSuppression::BoxEncodingType>

#include <non_max_suppression.hpp>

template <>
class AttributeAdapter<op::v9::NonMaxSuppression::BoxEncodingType>: public ov::EnumAttributeAdapterBase
{
public:
    // construction

    AttributeAdapter(op::v9::NonMaxSuppression::BoxEncodingType& value);

    // methods

    OPENVINO_RTTI("AttributeAdapter<ov::v9::NonMaxSuppression::BoxEncodingType>");
};

Inherited Members

public:
    // methods

    virtual const VAT& get() = 0;
    virtual void set(const VAT& value) = 0;
    void set_as_any(const ov::Any& x);
    virtual const std::string& get();
    virtual void set(const std::string& value);
    operator AT & ();
    void set_as_any(const ov::Any& x);

class ov::AttributeAdapter<op::v9::ROIAlign::PoolingMode>

#include <roi_align.hpp>

template <>
class AttributeAdapter<op::v9::ROIAlign::PoolingMode>: public ov::EnumAttributeAdapterBase
{
public:
    // construction

    AttributeAdapter(op::v9::ROIAlign::PoolingMode& value);

    // methods

    OPENVINO_RTTI("AttributeAdapter<ov::op::v9::ROIAlign::PoolingMode>");
};

Inherited Members

public:
    // methods

    virtual const VAT& get() = 0;
    virtual void set(const VAT& value) = 0;
    void set_as_any(const ov::Any& x);
    virtual const std::string& get();
    virtual void set(const std::string& value);
    operator AT & ();
    void set_as_any(const ov::Any& x);

class ov::AttributeAdapter<op::v9::ROIAlign::AlignedMode>

#include <roi_align.hpp>

template <>
class AttributeAdapter<op::v9::ROIAlign::AlignedMode>: public ov::EnumAttributeAdapterBase
{
public:
    // construction

    AttributeAdapter(op::v9::ROIAlign::AlignedMode& value);

    // methods

    OPENVINO_RTTI("AttributeAdapter<ov::op::v9::ROIAlign::AlignedMode>");
};

Inherited Members

public:
    // methods

    virtual const VAT& get() = 0;
    virtual void set(const VAT& value) = 0;
    void set_as_any(const ov::Any& x);
    virtual const std::string& get();
    virtual void set(const std::string& value);
    operator AT & ();
    void set_as_any(const ov::Any& x);

class ov::AttributeAdapter<ov::AxisSet>

Overview

#include <axis_set.hpp>

template <>
class AttributeAdapter<ov::AxisSet>: public ov::ValueAccessor
{
public:
    // construction

    AttributeAdapter(ov::AxisSet& value);

    // methods

    virtual const std::vector<int64_t>& get();
    virtual void set(const std::vector<int64_t>& value);
    operator ov::AxisSet & ();
    OPENVINO_RTTI("AttributeAdapter<AxisSet>");
};

Inherited Members

public:
    // methods

    virtual const VAT& get() = 0;
    virtual void set(const VAT& value) = 0;
    void set_as_any(const ov::Any& x);

Methods

virtual const std::vector<int64_t>& get()

Returns the value.

virtual void set(const std::vector<int64_t>& value)

Sets the value.

class ov::AttributeAdapter<std::shared_ptr<op::util::Variable>>

#include <variable.hpp>

template <>
class AttributeAdapter<std::shared_ptr<op::util::Variable>>: public ov::DirectValueAccessor
{
public:
    // construction

    AttributeAdapter(std::shared_ptr<op::util::Variable>& value);

    // methods

    OPENVINO_RTTI("AttributeAdapter<std::shared_ptr<ov::op::util::Variable>>");
};

Inherited Members

public:
    // methods

    virtual const VAT& get() = 0;
    virtual void set(const VAT& value) = 0;
    void set_as_any(const ov::Any& x);
    virtual const AT& get();
    virtual void set(const AT& value);

class ov::AttributeAdapter<std::shared_ptr<ov::Model>>

#include <model.hpp>

template <>
class AttributeAdapter<std::shared_ptr<ov::Model>>: public ov::DirectValueAccessor
{
public:
    // construction

    AttributeAdapter(std::shared_ptr<ov::Model>& value);

    // methods

    OPENVINO_RTTI();
};

Inherited Members

public:
    // methods

    virtual const VAT& get() = 0;
    virtual void set(const VAT& value) = 0;
    void set_as_any(const ov::Any& x);
    virtual const AT& get();
    virtual void set(const AT& value);

class ov::AttributeAdapter<std::shared_ptr<ov::Node>>

Visits a reference to a node that has been registered with the visitor.

#include <node.hpp>

template <>
class AttributeAdapter<std::shared_ptr<ov::Node>>: public ov::VisitorAdapter
{
public:
    // construction

    AttributeAdapter(std::shared_ptr<ov::Node>& value);

    // methods

    virtual bool visit_attributes(AttributeVisitor& visitor);
    OPENVINO_RTTI("AttributeAdapter<std::shared_ptr<Node>>");
};

Inherited Members

public:
    // methods

    virtual const DiscreteTypeInfo& get_type_info() const = 0;
    virtual void set_as_any(const ov::Any& x);
    virtual bool visit_attributes(AttributeVisitor& visitor) = 0;

class ov::AttributeAdapter<Strides>

#include <strides.hpp>

template <>
class AttributeAdapter<Strides>: public ov::IndirectVectorValueAccessor
{
public:
    // construction

    AttributeAdapter(Strides& value);

    // methods

    OPENVINO_RTTI("AttributeAdapter<Strides>");
};

Inherited Members

public:
    // methods

    virtual const VAT& get() = 0;
    virtual void set(const VAT& value) = 0;
    void set_as_any(const ov::Any& x);
    virtual const VAT& get();
    virtual void set(const VAT& value);
    void set_as_any(const ov::Any& x);
    operator AT & ();

class ov::AttributeAdapter<std::vector<uint8_t>>

Access a vector<uint8_t>

#include <attribute_adapter.hpp>

template <>
class AttributeAdapter<std::vector<uint8_t>>: public ov::DirectValueAccessor
{
public:
    // construction

    AttributeAdapter(std::vector<uint8_t>& value);

    // methods

    OPENVINO_RTTI();
};

Inherited Members

public:
    // methods

    virtual const VAT& get() = 0;
    virtual void set(const VAT& value) = 0;
    void set_as_any(const ov::Any& x);
    virtual const AT& get();
    virtual void set(const AT& value);

class ov::AttributeAdapter<std::vector<uint64_t>>

Access a vector<uint64_t>

#include <attribute_adapter.hpp>

template <>
class AttributeAdapter<std::vector<uint64_t>>: public ov::DirectValueAccessor
{
public:
    // construction

    AttributeAdapter(std::vector<uint64_t>& value);

    // methods

    OPENVINO_RTTI();
};

Inherited Members

public:
    // methods

    virtual const VAT& get() = 0;
    virtual void set(const VAT& value) = 0;
    void set_as_any(const ov::Any& x);
    virtual const AT& get();
    virtual void set(const AT& value);

class ov::AttributeAdapter<std::vector<uint32_t>>

Access a vector<uint32_t>

#include <attribute_adapter.hpp>

template <>
class AttributeAdapter<std::vector<uint32_t>>: public ov::DirectValueAccessor
{
public:
    // construction

    AttributeAdapter(std::vector<uint32_t>& value);

    // methods

    OPENVINO_RTTI();
};

Inherited Members

public:
    // methods

    virtual const VAT& get() = 0;
    virtual void set(const VAT& value) = 0;
    void set_as_any(const ov::Any& x);
    virtual const AT& get();
    virtual void set(const AT& value);

class ov::AttributeAdapter<uint16_t>

Access a uint16_t as an int64_t.

#include <attribute_adapter.hpp>

template <>
class AttributeAdapter<uint16_t>: public ov::IndirectScalarValueAccessor
{
public:
    // construction

    AttributeAdapter(uint16_t& value);

    // methods

    OPENVINO_RTTI("AttributeAdapter<uint16_t>");
};

Inherited Members

public:
    // methods

    virtual const VAT& get() = 0;
    virtual void set(const VAT& value) = 0;
    void set_as_any(const ov::Any& x);
    virtual const VAT& get();
    virtual void set(const VAT& value);
    void set_as_any(const ov::Any& x);

class ov::AttributeAdapter<uint64_t>

Access a uint64_t as an int64_t.

#include <attribute_adapter.hpp>

template <>
class AttributeAdapter<uint64_t>: public ov::IndirectScalarValueAccessor
{
public:
    // construction

    AttributeAdapter(uint64_t& value);

    // methods

    OPENVINO_RTTI("AttributeAdapter<uint64_t>");
};

Inherited Members

public:
    // methods

    virtual const VAT& get() = 0;
    virtual void set(const VAT& value) = 0;
    void set_as_any(const ov::Any& x);
    virtual const VAT& get();
    virtual void set(const VAT& value);
    void set_as_any(const ov::Any& x);

class ov::AttributeAdapter<uint32_t>

Access a uint32_t as an int64_t.

#include <attribute_adapter.hpp>

template <>
class AttributeAdapter<uint32_t>: public ov::IndirectScalarValueAccessor
{
public:
    // construction

    AttributeAdapter(uint32_t& value);

    // methods

    OPENVINO_RTTI("AttributeAdapter<uint32_t>");
};

Inherited Members

public:
    // methods

    virtual const VAT& get() = 0;
    virtual void set(const VAT& value) = 0;
    void set_as_any(const ov::Any& x);
    virtual const VAT& get();
    virtual void set(const VAT& value);
    void set_as_any(const ov::Any& x);

class ov::AttributeAdapter<uint8_t>

Access a uint8_t as an int64_t.

#include <attribute_adapter.hpp>

template <>
class AttributeAdapter<uint8_t>: public ov::IndirectScalarValueAccessor
{
public:
    // construction

    AttributeAdapter(uint8_t& value);

    // methods

    OPENVINO_RTTI("AttributeAdapter<uint8_t>");
};

Inherited Members

public:
    // methods

    virtual const VAT& get() = 0;
    virtual void set(const VAT& value) = 0;
    void set_as_any(const ov::Any& x);
    virtual const VAT& get();
    virtual void set(const VAT& value);
    void set_as_any(const ov::Any& x);

class ov::AttributeAdapter<op::v8::MatrixNms::DecayFunction>

#include <matrix_nms.hpp>

template <>
class AttributeAdapter<op::v8::MatrixNms::DecayFunction>: public ov::EnumAttributeAdapterBase
{
public:
    // construction

    AttributeAdapter(op::v8::MatrixNms::DecayFunction& value);

    // methods

    OPENVINO_RTTI("AttributeAdapter<ov::op::v8::MatrixNms::DecayFunction>");
};

Inherited Members

public:
    // methods

    virtual const VAT& get() = 0;
    virtual void set(const VAT& value) = 0;
    void set_as_any(const ov::Any& x);
    virtual const std::string& get();
    virtual void set(const std::string& value);
    operator AT & ();
    void set_as_any(const ov::Any& x);

class ov::AttributeAdapter<std::vector<uint16_t>>

Access a vector<uint16_t>

#include <attribute_adapter.hpp>

template <>
class AttributeAdapter<std::vector<uint16_t>>: public ov::DirectValueAccessor
{
public:
    // construction

    AttributeAdapter(std::vector<uint16_t>& value);

    // methods

    OPENVINO_RTTI();
};

Inherited Members

public:
    // methods

    virtual const VAT& get() = 0;
    virtual void set(const VAT& value) = 0;
    void set_as_any(const ov::Any& x);
    virtual const AT& get();
    virtual void set(const AT& value);

class ov::AttributeAdapter<std::vector<std::shared_ptr<op::util::MultiSubGraphOp::OutputDescription>>>

#include <multi_subgraph_base.hpp>

template <>
class AttributeAdapter<std::vector<std::shared_ptr<op::util::MultiSubGraphOp::OutputDescription>>>: public ov::DirectValueAccessor
{
public:
    // construction

    AttributeAdapter(std::vector<std::shared_ptr<op::util::MultiSubGraphOp::OutputDescription>>& value);

    // methods

    OPENVINO_RTTI("AttributeAdapter<std::vector<std::shared_ptr<ov::op::util::MultiSubGraphOp::OutputDescription>>>");
};

Inherited Members

public:
    // methods

    virtual const VAT& get() = 0;
    virtual void set(const VAT& value) = 0;
    void set_as_any(const ov::Any& x);
    virtual const AT& get();
    virtual void set(const AT& value);

class ov::AttributeAdapter<std::vector<float>>

Access a vector<float>

#include <attribute_adapter.hpp>

template <>
class AttributeAdapter<std::vector<float>>: public ov::DirectValueAccessor
{
public:
    // construction

    AttributeAdapter(std::vector<float>& value);

    // methods

    OPENVINO_RTTI();
};

Inherited Members

public:
    // methods

    virtual const VAT& get() = 0;
    virtual void set(const VAT& value) = 0;
    void set_as_any(const ov::Any& x);
    virtual const AT& get();
    virtual void set(const AT& value);

class ov::AttributeAdapter<std::vector<double>>

Access a vector<double>

#include <attribute_adapter.hpp>

template <>
class AttributeAdapter<std::vector<double>>: public ov::DirectValueAccessor
{
public:
    // construction

    AttributeAdapter(std::vector<double>& value);

    // methods

    OPENVINO_RTTI();
};

Inherited Members

public:
    // methods

    virtual const VAT& get() = 0;
    virtual void set(const VAT& value) = 0;
    void set_as_any(const ov::Any& x);
    virtual const AT& get();
    virtual void set(const AT& value);

class ov::AttributeAdapter<std::string>

Access a string as a string.

#include <attribute_adapter.hpp>

template <>
class AttributeAdapter<std::string>: public ov::DirectValueAccessor
{
public:
    // construction

    AttributeAdapter(std::string& value);

    // methods

    OPENVINO_RTTI("AttributeAdapter<std::string>");
};

Inherited Members

public:
    // methods

    virtual const VAT& get() = 0;
    virtual void set(const VAT& value) = 0;
    void set_as_any(const ov::Any& x);
    virtual const AT& get();
    virtual void set(const AT& value);

class ov::AttributeAdapter<std::vector<std::string>>

Access a vector<string>

#include <attribute_adapter.hpp>

template <>
class AttributeAdapter<std::vector<std::string>>: public ov::DirectValueAccessor
{
public:
    // construction

    AttributeAdapter(std::vector<std::string>& value);

    // methods

    OPENVINO_RTTI();
};

Inherited Members

public:
    // methods

    virtual const VAT& get() = 0;
    virtual void set(const VAT& value) = 0;
    void set_as_any(const ov::Any& x);
    virtual const AT& get();
    virtual void set(const AT& value);

class ov::AttributeAdapter<std::vector<int16_t>>

Access a vector<int16_t>

#include <attribute_adapter.hpp>

template <>
class AttributeAdapter<std::vector<int16_t>>: public ov::DirectValueAccessor
{
public:
    // construction

    AttributeAdapter(std::vector<int16_t>& value);

    // methods

    OPENVINO_RTTI();
};

Inherited Members

public:
    // methods

    virtual const VAT& get() = 0;
    virtual void set(const VAT& value) = 0;
    void set_as_any(const ov::Any& x);
    virtual const AT& get();
    virtual void set(const AT& value);

class ov::AttributeAdapter<std::vector<int64_t>>

Access a vector<int64_t>

#include <attribute_adapter.hpp>

template <>
class AttributeAdapter<std::vector<int64_t>>: public ov::DirectValueAccessor
{
public:
    // construction

    AttributeAdapter(std::vector<int64_t>& value);

    // methods

    OPENVINO_RTTI();
};

Inherited Members

public:
    // methods

    virtual const VAT& get() = 0;
    virtual void set(const VAT& value) = 0;
    void set_as_any(const ov::Any& x);
    virtual const AT& get();
    virtual void set(const AT& value);

class ov::AttributeAdapter<std::vector<int32_t>>

Access a vector<int32_t>

#include <attribute_adapter.hpp>

template <>
class AttributeAdapter<std::vector<int32_t>>: public ov::DirectValueAccessor
{
public:
    // construction

    AttributeAdapter(std::vector<int32_t>& value);

    // methods

    OPENVINO_RTTI();
};

Inherited Members

public:
    // methods

    virtual const VAT& get() = 0;
    virtual void set(const VAT& value) = 0;
    void set_as_any(const ov::Any& x);
    virtual const AT& get();
    virtual void set(const AT& value);

class ov::AttributeAdapter<std::vector<int8_t>>

Overview

Access a vector<int8_t> More…

#include <attribute_adapter.hpp>

template <>
class AttributeAdapter<std::vector<int8_t>>: public ov::DirectValueAccessor
{
public:
    // construction

    AttributeAdapter(std::vector<int8_t>& value);

    // methods

    OPENVINO_RTTI();
};

Inherited Members

public:
    // methods

    virtual const VAT& get() = 0;
    virtual void set(const VAT& value) = 0;
    void set_as_any(const ov::Any& x);
    virtual const AT& get();
    virtual void set(const AT& value);

Access a vector<int8_t>

Note: These class bodies cannot be defined with templates because of interactions between dllexport and templates on Windows.

class ov::AttributeAdapter<op::v5::Round::RoundMode>

#include <round.hpp>

template <>
class AttributeAdapter<op::v5::Round::RoundMode>: public ov::EnumAttributeAdapterBase
{
public:
    // construction

    AttributeAdapter(op::v5::Round::RoundMode& value);

    // methods

    OPENVINO_RTTI("AttributeAdapter<ov::op::v5::Round::RoundMode>");
};

Inherited Members

public:
    // methods

    virtual const VAT& get() = 0;
    virtual void set(const VAT& value) = 0;
    void set_as_any(const ov::Any& x);
    virtual const std::string& get();
    virtual void set(const std::string& value);
    operator AT & ();
    void set_as_any(const ov::Any& x);

class ov::AttributeAdapter<std::vector<std::shared_ptr<op::util::MultiSubGraphOp::InputDescription>>>

#include <multi_subgraph_base.hpp>

template <>
class AttributeAdapter<std::vector<std::shared_ptr<op::util::MultiSubGraphOp::InputDescription>>>: public ov::DirectValueAccessor
{
public:
    // construction

    AttributeAdapter(std::vector<std::shared_ptr<op::util::MultiSubGraphOp::InputDescription>>& value);
};

Inherited Members

public:
    // methods

    virtual const VAT& get() = 0;
    virtual void set(const VAT& value) = 0;
    void set_as_any(const ov::Any& x);
    virtual const AT& get();
    virtual void set(const AT& value);

class ov::AttributeAdapter<op::v5::Loop::SpecialBodyPorts>

#include <loop.hpp>

template <>
class AttributeAdapter<op::v5::Loop::SpecialBodyPorts>: public ov::DirectValueAccessor
{
public:
    // construction

    AttributeAdapter(op::v5::Loop::SpecialBodyPorts& value);

    // methods

    OPENVINO_RTTI("AttributeAdapter<ov::op::v5::Loop::SpecialBodyPorts>");
};

Inherited Members

public:
    // methods

    virtual const VAT& get() = 0;
    virtual void set(const VAT& value) = 0;
    void set_as_any(const ov::Any& x);
    virtual const AT& get();
    virtual void set(const AT& value);

class ov::AttributeAdapter<ngraph::reduction::Type>

#include <distributed.hpp>

template <>
class AttributeAdapter<ngraph::reduction::Type>: public ov::EnumAttributeAdapterBase
{
public:
    // construction

    AttributeAdapter(ngraph::reduction::Type& value);

    // methods

    OPENVINO_RTTI("AttributeAdapter<reduction::Type>");
};

Inherited Members

public:
    // methods

    virtual const VAT& get() = 0;
    virtual void set(const VAT& value) = 0;
    void set_as_any(const ov::Any& x);
    virtual const std::string& get();
    virtual void set(const std::string& value);
    operator AT & ();
    void set_as_any(const ov::Any& x);

class ov::AttributeAdapter<Layout>

Overview

#include <layout.hpp>

template <>
class AttributeAdapter<Layout>: public ov::ValueAccessor
{
public:
    // construction

    AttributeAdapter(Layout& value);

    // methods

    OPENVINO_RTTI("AttributeAdapter<Layout>");
    virtual const std::string& get();
    virtual void set(const std::string& value);
    operator Layout & ();
};

Inherited Members

public:
    // methods

    virtual const VAT& get() = 0;
    virtual void set(const VAT& value) = 0;
    void set_as_any(const ov::Any& x);

Methods

virtual const std::string& get()

Returns the value.

virtual void set(const std::string& value)

Sets the value.

class ov::AttributeAdapter<op::v5::NonMaxSuppression::BoxEncodingType>

#include <non_max_suppression.hpp>

template <>
class AttributeAdapter<op::v5::NonMaxSuppression::BoxEncodingType>: public ov::EnumAttributeAdapterBase
{
public:
    // construction

    AttributeAdapter(op::v5::NonMaxSuppression::BoxEncodingType& value);

    // methods

    OPENVINO_RTTI("AttributeAdapter<ov::v5::NonMaxSuppression::BoxEncodingType>");
};

Inherited Members

public:
    // methods

    virtual const VAT& get() = 0;
    virtual void set(const VAT& value) = 0;
    void set_as_any(const ov::Any& x);
    virtual const std::string& get();
    virtual void set(const std::string& value);
    operator AT & ();
    void set_as_any(const ov::Any& x);

class ov::AttributeAdapter<int8_t>

Access an int8_t and an int64_t.

#include <attribute_adapter.hpp>

template <>
class AttributeAdapter<int8_t>: public ov::IndirectScalarValueAccessor
{
public:
    // construction

    AttributeAdapter(int8_t& value);

    // methods

    OPENVINO_RTTI("AttributeAdapter<int8_t>");
};

Inherited Members

public:
    // methods

    virtual const VAT& get() = 0;
    virtual void set(const VAT& value) = 0;
    void set_as_any(const ov::Any& x);
    virtual const VAT& get();
    virtual void set(const VAT& value);
    void set_as_any(const ov::Any& x);

class ov::AttributeAdapter<op::AutoBroadcastSpec>

#include <attr_types.hpp>

template <>
class AttributeAdapter<op::AutoBroadcastSpec>: public ov::VisitorAdapter
{
public:
    // construction

    AttributeAdapter(op::AutoBroadcastSpec& value);

    // methods

    virtual bool visit_attributes(AttributeVisitor& visitor);
    OPENVINO_RTTI("AttributeAdapter<AutoBroadcastSpec>");
};

Inherited Members

public:
    // methods

    virtual const DiscreteTypeInfo& get_type_info() const = 0;
    virtual void set_as_any(const ov::Any& x);
    virtual bool visit_attributes(AttributeVisitor& visitor) = 0;

class ov::AttributeAdapter<op::BroadcastType>

#include <attr_types.hpp>

template <>
class AttributeAdapter<op::BroadcastType>: public ov::EnumAttributeAdapterBase
{
public:
    // construction

    AttributeAdapter(op::BroadcastType& value);

    // methods

    OPENVINO_RTTI("AttributeAdapter<BroadcastType>");
};

Inherited Members

public:
    // methods

    virtual const VAT& get() = 0;
    virtual void set(const VAT& value) = 0;
    void set_as_any(const ov::Any& x);
    virtual const std::string& get();
    virtual void set(const std::string& value);
    operator AT & ();
    void set_as_any(const ov::Any& x);

class ov::AttributeAdapter<op::AutoBroadcastType>

#include <attr_types.hpp>

template <>
class AttributeAdapter<op::AutoBroadcastType>: public ov::EnumAttributeAdapterBase
{
public:
    // construction

    AttributeAdapter(op::AutoBroadcastType& value);

    // methods

    OPENVINO_RTTI("AttributeAdapter<AutoBroadcastType>");
};

Inherited Members

public:
    // methods

    virtual const VAT& get() = 0;
    virtual void set(const VAT& value) = 0;
    void set_as_any(const ov::Any& x);
    virtual const std::string& get();
    virtual void set(const std::string& value);
    operator AT & ();
    void set_as_any(const ov::Any& x);

class ov::AttributeAdapter<op::EpsMode>

#include <attr_types.hpp>

template <>
class AttributeAdapter<op::EpsMode>: public ov::EnumAttributeAdapterBase
{
public:
    // construction

    AttributeAdapter(op::EpsMode& value);

    // methods

    OPENVINO_RTTI("AttributeAdapter<EpsMode>");
};

Inherited Members

public:
    // methods

    virtual const VAT& get() = 0;
    virtual void set(const VAT& value) = 0;
    void set_as_any(const ov::Any& x);
    virtual const std::string& get();
    virtual void set(const std::string& value);
    operator AT & ();
    void set_as_any(const ov::Any& x);

class ov::AttributeAdapter<op::GeluApproximationMode>

#include <gelu.hpp>

template <>
class AttributeAdapter<op::GeluApproximationMode>: public ov::EnumAttributeAdapterBase
{
public:
    // construction

    AttributeAdapter(op::GeluApproximationMode& value);

    // methods

    OPENVINO_RTTI("AttributeAdapter<ov::op::GeluApproximationMode>");
};

Inherited Members

public:
    // methods

    virtual const VAT& get() = 0;
    virtual void set(const VAT& value) = 0;
    void set_as_any(const ov::Any& x);
    virtual const std::string& get();
    virtual void set(const std::string& value);
    operator AT & ();
    void set_as_any(const ov::Any& x);

class ov::AttributeAdapter<int64_t>

Access an int64_t as an int64_t.

#include <attribute_adapter.hpp>

template <>
class AttributeAdapter<int64_t>: public ov::DirectValueAccessor
{
public:
    // construction

    AttributeAdapter(int64_t& value);

    // methods

    OPENVINO_RTTI("AttributeAdapter<int64_t>");
};

Inherited Members

public:
    // methods

    virtual const VAT& get() = 0;
    virtual void set(const VAT& value) = 0;
    void set_as_any(const ov::Any& x);
    virtual const AT& get();
    virtual void set(const AT& value);

class ov::AttributeAdapter<int16_t>

Access an int16_t as an int64_t.

#include <attribute_adapter.hpp>

template <>
class AttributeAdapter<int16_t>: public ov::IndirectScalarValueAccessor
{
public:
    // construction

    AttributeAdapter(int16_t& value);

    // methods

    OPENVINO_RTTI("AttributeAdapter<int16_t>");
};

Inherited Members

public:
    // methods

    virtual const VAT& get() = 0;
    virtual void set(const VAT& value) = 0;
    void set_as_any(const ov::Any& x);
    virtual const VAT& get();
    virtual void set(const VAT& value);
    void set_as_any(const ov::Any& x);

class ov::AttributeAdapter<bool>

Access a bool as a bool.

#include <attribute_adapter.hpp>

template <>
class AttributeAdapter<bool>: public ov::DirectValueAccessor
{
public:
    // construction

    AttributeAdapter(bool& value);

    // methods

    OPENVINO_RTTI("AttributeAdapter<bool>");
};

Inherited Members

public:
    // methods

    virtual const VAT& get() = 0;
    virtual void set(const VAT& value) = 0;
    void set_as_any(const ov::Any& x);
    virtual const AT& get();
    virtual void set(const AT& value);

class ov::AttributeAdapter<AxisVector>

#include <axis_vector.hpp>

template <>
class AttributeAdapter<AxisVector>: public ov::IndirectVectorValueAccessor
{
public:
    // construction

    AttributeAdapter(AxisVector& value);

    // methods

    OPENVINO_RTTI("AttributeAdapter<AxisVector>");
};

Inherited Members

public:
    // methods

    virtual const VAT& get() = 0;
    virtual void set(const VAT& value) = 0;
    void set_as_any(const ov::Any& x);
    virtual const VAT& get();
    virtual void set(const VAT& value);
    void set_as_any(const ov::Any& x);
    operator AT & ();

class ov::AttributeAdapter

An AttributeAdapter “captures” an attribute as an AT& and makes it available as a ValueAccessor<VAT>.

class ov::AttributeAdapter<int32_t>

Access an int32_t as an int64_t.

#include <attribute_adapter.hpp>

template <>
class AttributeAdapter<int32_t>: public ov::IndirectScalarValueAccessor
{
public:
    // construction

    AttributeAdapter(int32_t& value);

    // methods

    OPENVINO_RTTI("AttributeAdapter<int32_t>");
};

Inherited Members

public:
    // methods

    virtual const VAT& get() = 0;
    virtual void set(const VAT& value) = 0;
    void set_as_any(const ov::Any& x);
    virtual const VAT& get();
    virtual void set(const VAT& value);
    void set_as_any(const ov::Any& x);

class ov::AttributeAdapter<Coordinate>

#include <coordinate.hpp>

template <>
class AttributeAdapter<Coordinate>: public ov::IndirectVectorValueAccessor
{
public:
    // construction

    AttributeAdapter(Coordinate& value);

    // methods

    OPENVINO_RTTI("AttributeAdapter<Coordinate>");
};

Inherited Members

public:
    // methods

    virtual const VAT& get() = 0;
    virtual void set(const VAT& value) = 0;
    void set_as_any(const ov::Any& x);
    virtual const VAT& get();
    virtual void set(const VAT& value);
    void set_as_any(const ov::Any& x);
    operator AT & ();

class ov::AttributeAdapter<double>

Access a double as a double.

#include <attribute_adapter.hpp>

template <>
class AttributeAdapter<double>: public ov::DirectValueAccessor
{
public:
    // construction

    AttributeAdapter(double& value);

    // methods

    OPENVINO_RTTI("AttributeAdapter<double>");
};

Inherited Members

public:
    // methods

    virtual const VAT& get() = 0;
    virtual void set(const VAT& value) = 0;
    void set_as_any(const ov::Any& x);
    virtual const AT& get();
    virtual void set(const AT& value);

class ov::AttributeAdapter<CoordinateDiff>

#include <coordinate_diff.hpp>

template <>
class AttributeAdapter<CoordinateDiff>: public ov::IndirectVectorValueAccessor
{
public:
    // construction

    AttributeAdapter(CoordinateDiff& value);

    // methods

    OPENVINO_RTTI("AttributeAdapter<CoordinateDiff>");
};

Inherited Members

public:
    // methods

    virtual const VAT& get() = 0;
    virtual void set(const VAT& value) = 0;
    void set_as_any(const ov::Any& x);
    virtual const VAT& get();
    virtual void set(const VAT& value);
    void set_as_any(const ov::Any& x);
    operator AT & ();

class ov::AttributeAdapter<float>

#include <attribute_adapter.hpp>

template <>
class AttributeAdapter<float>: public ov::IndirectScalarValueAccessor
{
public:
    // construction

    AttributeAdapter(float& value);

    // methods

    OPENVINO_RTTI("AttributeAdapter<float>");
};

Inherited Members

public:
    // methods

    virtual const VAT& get() = 0;
    virtual void set(const VAT& value) = 0;
    void set_as_any(const ov::Any& x);
    virtual const VAT& get();
    virtual void set(const VAT& value);
    void set_as_any(const ov::Any& x);

class ov::AttributeAdapter<op::LSTMWeightsFormat>

#include <lstm_cell.hpp>

template <>
class AttributeAdapter<op::LSTMWeightsFormat>: public ov::EnumAttributeAdapterBase
{
public:
    // construction

    AttributeAdapter(op::LSTMWeightsFormat& value);

    // methods

    OPENVINO_RTTI("AttributeAdapter<ov::op::LSTMWeightsFormat>");
};

Inherited Members

public:
    // methods

    virtual const VAT& get() = 0;
    virtual void set(const VAT& value) = 0;
    void set_as_any(const ov::Any& x);
    virtual const std::string& get();
    virtual void set(const std::string& value);
    operator AT & ();
    void set_as_any(const ov::Any& x);

class ov::AttributeAdapter<op::BroadcastModeSpec>

#include <attr_types.hpp>

template <>
class AttributeAdapter<op::BroadcastModeSpec>: public ov::VisitorAdapter
{
public:
    // construction

    AttributeAdapter(op::BroadcastModeSpec& value);

    // methods

    virtual bool visit_attributes(AttributeVisitor& visitor);
    OPENVINO_RTTI("AttributeAdapter<BroadcastModeSpec>");
};

Inherited Members

public:
    // methods

    virtual const DiscreteTypeInfo& get_type_info() const = 0;
    virtual void set_as_any(const ov::Any& x);
    virtual bool visit_attributes(AttributeVisitor& visitor) = 0;

class ov::AttributeAdapter<op::PadMode>

#include <attr_types.hpp>

template <>
class AttributeAdapter<op::PadMode>: public ov::EnumAttributeAdapterBase
{
public:
    // construction

    AttributeAdapter(op::PadMode& value);

    // methods

    OPENVINO_RTTI("AttributeAdapter<PadMode>");
};

Inherited Members

public:
    // methods

    virtual const VAT& get() = 0;
    virtual void set(const VAT& value) = 0;
    void set_as_any(const ov::Any& x);
    virtual const std::string& get();
    virtual void set(const std::string& value);
    operator AT & ();
    void set_as_any(const ov::Any& x);

class ov::AttributeAdapter<op::MVNEpsMode>

#include <mvn.hpp>

template <>
class AttributeAdapter<op::MVNEpsMode>: public ov::EnumAttributeAdapterBase
{
public:
    // construction

    AttributeAdapter(op::MVNEpsMode& value);

    // methods

    OPENVINO_RTTI("AttributeAdapter<ov::op::MVNEpsMode>");
};

Inherited Members

public:
    // methods

    virtual const VAT& get() = 0;
    virtual void set(const VAT& value) = 0;
    void set_as_any(const ov::Any& x);
    virtual const std::string& get();
    virtual void set(const std::string& value);
    operator AT & ();
    void set_as_any(const ov::Any& x);

class ov::AttributeAdapter<op::v1::Reverse::Mode>

#include <reverse.hpp>

template <>
class AttributeAdapter<op::v1::Reverse::Mode>: public ov::EnumAttributeAdapterBase
{
public:
    // construction

    AttributeAdapter(op::v1::Reverse::Mode& value);

    // methods

    OPENVINO_RTTI("AttributeAdapter<ov::op::v1::Reverse::Mode>");
};

Inherited Members

public:
    // methods

    virtual const VAT& get() = 0;
    virtual void set(const VAT& value) = 0;
    void set_as_any(const ov::Any& x);
    virtual const std::string& get();
    virtual void set(const std::string& value);
    operator AT & ();
    void set_as_any(const ov::Any& x);

class ov::AttributeAdapter<op::v1::NonMaxSuppression::BoxEncodingType>

#include <non_max_suppression.hpp>

template <>
class AttributeAdapter<op::v1::NonMaxSuppression::BoxEncodingType>: public ov::EnumAttributeAdapterBase
{
public:
    // construction

    AttributeAdapter(op::v1::NonMaxSuppression::BoxEncodingType& value);

    // methods

    OPENVINO_RTTI("AttributeAdapter<ov::v1::NonMaxSuppression::BoxEncodingType>");
};

Inherited Members

public:
    // methods

    virtual const VAT& get() = 0;
    virtual void set(const VAT& value) = 0;
    void set_as_any(const ov::Any& x);
    virtual const std::string& get();
    virtual void set(const std::string& value);
    operator AT & ();
    void set_as_any(const ov::Any& x);

class ov::AttributeAdapter<op::v1::BinaryConvolution::BinaryConvolutionMode>

#include <binary_convolution.hpp>

template <>
class AttributeAdapter<op::v1::BinaryConvolution::BinaryConvolutionMode>: public ov::EnumAttributeAdapterBase
{
public:
    // construction

    AttributeAdapter(op::v1::BinaryConvolution::BinaryConvolutionMode& value);

    // methods

    OPENVINO_RTTI("AttributeAdapter<ov::op::v1::BinaryConvolution::BinaryConvolutionMode>");
};

Inherited Members

public:
    // methods

    virtual const VAT& get() = 0;
    virtual void set(const VAT& value) = 0;
    void set_as_any(const ov::Any& x);
    virtual const std::string& get();
    virtual void set(const std::string& value);
    operator AT & ();
    void set_as_any(const ov::Any& x);

class ov::AttributeAdapter<op::v3::ROIAlign::PoolingMode>

#include <roi_align.hpp>

template <>
class AttributeAdapter<op::v3::ROIAlign::PoolingMode>: public ov::EnumAttributeAdapterBase
{
public:
    // construction

    AttributeAdapter(op::v3::ROIAlign::PoolingMode& value);

    // methods

    OPENVINO_RTTI("AttributeAdapter<ov::op::v3::ROIAlign::PoolingMode>");
};

Inherited Members

public:
    // methods

    virtual const VAT& get() = 0;
    virtual void set(const VAT& value) = 0;
    void set_as_any(const ov::Any& x);
    virtual const std::string& get();
    virtual void set(const std::string& value);
    operator AT & ();
    void set_as_any(const ov::Any& x);

class ov::AttributeAdapter<op::v4::Interpolate::InterpolateMode>

#include <interpolate.hpp>

template <>
class AttributeAdapter<op::v4::Interpolate::InterpolateMode>: public ov::EnumAttributeAdapterBase
{
public:
    // construction

    AttributeAdapter(op::v4::Interpolate::InterpolateMode& value);

    // methods

    OPENVINO_RTTI("AttributeAdapter<ov::op::v4::Interpolate::InterpolateMode>");
};

Inherited Members

public:
    // methods

    virtual const VAT& get() = 0;
    virtual void set(const VAT& value) = 0;
    void set_as_any(const ov::Any& x);
    virtual const std::string& get();
    virtual void set(const std::string& value);
    operator AT & ();
    void set_as_any(const ov::Any& x);

class ov::AttributeAdapter<op::v4::Interpolate::CoordinateTransformMode>

#include <interpolate.hpp>

template <>
class AttributeAdapter<op::v4::Interpolate::CoordinateTransformMode>: public ov::EnumAttributeAdapterBase
{
public:
    // construction

    AttributeAdapter(op::v4::Interpolate::CoordinateTransformMode& value);

    // methods

    OPENVINO_RTTI("AttributeAdapter<ov::op::v4::Interpolate::CoordinateTransformMode>");
};

Inherited Members

public:
    // methods

    virtual const VAT& get() = 0;
    virtual void set(const VAT& value) = 0;
    void set_as_any(const ov::Any& x);
    virtual const std::string& get();
    virtual void set(const std::string& value);
    operator AT & ();
    void set_as_any(const ov::Any& x);

class ov::AttributeAdapter<op::v4::Interpolate::ShapeCalcMode>

#include <interpolate.hpp>

template <>
class AttributeAdapter<op::v4::Interpolate::ShapeCalcMode>: public ov::EnumAttributeAdapterBase
{
public:
    // construction

    AttributeAdapter(op::v4::Interpolate::ShapeCalcMode& value);

    // methods

    OPENVINO_RTTI("AttributeAdapter<ov::op::v4::Interpolate::ShapeCalcMode>");
};

Inherited Members

public:
    // methods

    virtual const VAT& get() = 0;
    virtual void set(const VAT& value) = 0;
    void set_as_any(const ov::Any& x);
    virtual const std::string& get();
    virtual void set(const std::string& value);
    operator AT & ();
    void set_as_any(const ov::Any& x);

class ov::AttributeAdapter<op::v4::Interpolate::NearestMode>

#include <interpolate.hpp>

template <>
class AttributeAdapter<op::v4::Interpolate::NearestMode>: public ov::EnumAttributeAdapterBase
{
public:
    // construction

    AttributeAdapter(op::v4::Interpolate::NearestMode& value);

    // methods

    OPENVINO_RTTI("AttributeAdapter<ov::op::v4::Interpolate::NearestMode>");
};

Inherited Members

public:
    // methods

    virtual const VAT& get() = 0;
    virtual void set(const VAT& value) = 0;
    void set_as_any(const ov::Any& x);
    virtual const std::string& get();
    virtual void set(const std::string& value);
    operator AT & ();
    void set_as_any(const ov::Any& x);

class ov::AttributeAdapter<op::v0::SpaceToDepth::SpaceToDepthMode>

#include <space_to_depth.hpp>

template <>
class AttributeAdapter<op::v0::SpaceToDepth::SpaceToDepthMode>: public ov::EnumAttributeAdapterBase
{
public:
    // construction

    AttributeAdapter(op::v0::SpaceToDepth::SpaceToDepthMode& value);

    // methods

    OPENVINO_RTTI("AttributeAdapter<ov::op::v0::SpaceToDepth::SpaceToDepthMode>");
};

Inherited Members

public:
    // methods

    virtual const VAT& get() = 0;
    virtual void set(const VAT& value) = 0;
    void set_as_any(const ov::Any& x);
    virtual const std::string& get();
    virtual void set(const std::string& value);
    operator AT & ();
    void set_as_any(const ov::Any& x);

class ov::AttributeAdapter<op::v3::NonMaxSuppression::BoxEncodingType>

#include <non_max_suppression.hpp>

template <>
class AttributeAdapter<op::v3::NonMaxSuppression::BoxEncodingType>: public ov::EnumAttributeAdapterBase
{
public:
    // construction

    AttributeAdapter(op::v3::NonMaxSuppression::BoxEncodingType& value);

    // methods

    OPENVINO_RTTI("AttributeAdapter<ov::v3::NonMaxSuppression::BoxEncodingType>");
};

Inherited Members

public:
    // methods

    virtual const VAT& get() = 0;
    virtual void set(const VAT& value) = 0;
    void set_as_any(const ov::Any& x);
    virtual const std::string& get();
    virtual void set(const std::string& value);
    operator AT & ();
    void set_as_any(const ov::Any& x);

class ov::AttributeAdapter<op::v0::DepthToSpace::DepthToSpaceMode>

#include <depth_to_space.hpp>

template <>
class AttributeAdapter<op::v0::DepthToSpace::DepthToSpaceMode>: public ov::EnumAttributeAdapterBase
{
public:
    // construction

    AttributeAdapter(op::v0::DepthToSpace::DepthToSpaceMode& value);

    // methods

    OPENVINO_RTTI("AttributeAdapter<ov::op::v0::DepthToSpace::DepthToSpaceMode>");
};

Inherited Members

public:
    // methods

    virtual const VAT& get() = 0;
    virtual void set(const VAT& value) = 0;
    void set_as_any(const ov::Any& x);
    virtual const std::string& get();
    virtual void set(const std::string& value);
    operator AT & ();
    void set_as_any(const ov::Any& x);

class ov::AttributeAdapter<op::RoundingType>

#include <attr_types.hpp>

template <>
class AttributeAdapter<op::RoundingType>: public ov::EnumAttributeAdapterBase
{
public:
    // construction

    AttributeAdapter(op::RoundingType& value);

    // methods

    OPENVINO_RTTI("AttributeAdapter<RoundingType>");
};

Inherited Members

public:
    // methods

    virtual const VAT& get() = 0;
    virtual void set(const VAT& value) = 0;
    void set_as_any(const ov::Any& x);
    virtual const std::string& get();
    virtual void set(const std::string& value);
    operator AT & ();
    void set_as_any(const ov::Any& x);

class ov::AttributeAdapter<op::v0::Interpolate::InterpolateMode>

#include <interpolate.hpp>

template <>
class AttributeAdapter<op::v0::Interpolate::InterpolateMode>: public ov::EnumAttributeAdapterBase
{
public:
    // construction

    AttributeAdapter(op::v0::Interpolate::InterpolateMode& value);

    // methods

    OPENVINO_RTTI("AttributeAdapter<ov::op::v0::Interpolate::InterpolateMode>");
};

Inherited Members

public:
    // methods

    virtual const VAT& get() = 0;
    virtual void set(const VAT& value) = 0;
    void set_as_any(const ov::Any& x);
    virtual const std::string& get();
    virtual void set(const std::string& value);
    operator AT & ();
    void set_as_any(const ov::Any& x);

class ov::AttributeAdapter<op::RecurrentSequenceDirection>

#include <attr_types.hpp>

template <>
class AttributeAdapter<op::RecurrentSequenceDirection>: public ov::EnumAttributeAdapterBase
{
public:
    // construction

    AttributeAdapter(op::RecurrentSequenceDirection& value);

    // methods

    OPENVINO_RTTI("AttributeAdapter<RecurrentSequenceDirection>");
};

Inherited Members

public:
    // methods

    virtual const VAT& get() = 0;
    virtual void set(const VAT& value) = 0;
    void set_as_any(const ov::Any& x);
    virtual const std::string& get();
    virtual void set(const std::string& value);
    operator AT & ();
    void set_as_any(const ov::Any& x);

class ov::AttributeAdapter<op::TopKMode>

#include <attr_types.hpp>

template <>
class AttributeAdapter<op::TopKMode>: public ov::EnumAttributeAdapterBase
{
public:
    // construction

    AttributeAdapter(op::TopKMode& value);

    // methods

    OPENVINO_RTTI("AttributeAdapter<TopKMode>");
};

Inherited Members

public:
    // methods

    virtual const VAT& get() = 0;
    virtual void set(const VAT& value) = 0;
    void set_as_any(const ov::Any& x);
    virtual const std::string& get();
    virtual void set(const std::string& value);
    operator AT & ();
    void set_as_any(const ov::Any& x);

class ov::AttributeAdapter<op::util::MulticlassNmsBase::SortResultType>

#include <multiclass_nms_base.hpp>

template <>
class AttributeAdapter<op::util::