class ngraph::AttributeAdapter

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

class ngraph::AttributeAdapter<ResultVector>

Overview

#include <result.hpp>

template <>
class AttributeAdapter<ResultVector>: public ngraph::VisitorAdapter
{
public:
    // fields

    static constexpr DiscreteTypeInfo type_info {"AttributeAdapter<ResultVector>", 0};

    // construction

    AttributeAdapter(ResultVector& ref);

    // methods

    virtual bool visit_attributes(AttributeVisitor& visitor);
    virtual const DiscreteTypeInfo& get_type_info() const;
};

Inherited Members

public:
    // methods

    virtual const DiscreteTypeInfo& get_type_info() const = 0;
    virtual bool visit_attributes(AttributeVisitor& visitor) = 0;

Detailed Documentation

Methods

virtual const DiscreteTypeInfo& get_type_info() const

type info enables identification of the value accessor, as well as is_type and as_type.

class ngraph::AttributeAdapter<reduction::Type>

#include <distributed.hpp>

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

    static constexpr DiscreteTypeInfo type_info {"AttributeAdapter<reduction::Type>", 0};

    // construction

    AttributeAdapter(reduction::Type& value);

    // methods

    const DiscreteTypeInfo& get_type_info() const;
};
public:
    // methods

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

class ngraph::AttributeAdapter<PartialShape>

Overview

#include <partial_shape.hpp>

template <>
class AttributeAdapter<PartialShape>: public ngraph::ValueAccessor
{
public:
    // fields

    static constexpr DiscreteTypeInfo type_info {"AttributeAdapter<PartialShape>", 0};

    // construction

    AttributeAdapter(PartialShape& value);

    // methods

    virtual const std::vector<int64_t>& get();
    virtual void set(const std::vector<int64_t>& value);
    const DiscreteTypeInfo& get_type_info() const;
    operator PartialShape & ();
};

Inherited Members

public:
    // methods

    virtual const VAT& get() = 0;
    virtual void set(const VAT& value) = 0;

Detailed Documentation

Methods

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

Returns the value.

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

Sets the value.

class ngraph::AttributeAdapter<Shape>

#include <shape.hpp>

template <>
class AttributeAdapter<Shape>: public ngraph::IndirectVectorValueAccessor
{
public:
    // fields

    static constexpr DiscreteTypeInfo type_info {"AttributeAdapter<Shape>", 0};

    // construction

    AttributeAdapter(Shape& value);

    // methods

    const DiscreteTypeInfo& get_type_info() const;
};
public:
    // methods

    virtual const VAT& get() = 0;
    virtual void set(const VAT& value) = 0;
    virtual const VAT& get();
    virtual void set(const VAT& value);
    operator AT & ();

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

Overview

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

#include <node.hpp>

template <>
class AttributeAdapter<std::shared_ptr<Node>>: public ngraph::VisitorAdapter
{
public:
    // fields

    static constexpr DiscreteTypeInfo type_info {"AttributeAdapter<std::shared_ptr<Node>>", 0};

    // construction

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

    // methods

    virtual bool visit_attributes(AttributeVisitor& visitor);
    virtual const DiscreteTypeInfo& get_type_info() const;
};

Inherited Members

public:
    // methods

    virtual const DiscreteTypeInfo& get_type_info() const = 0;
    virtual bool visit_attributes(AttributeVisitor& visitor) = 0;

Detailed Documentation

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

Methods

virtual const DiscreteTypeInfo& get_type_info() const

type info enables identification of the value accessor, as well as is_type and as_type.

class ngraph::AttributeAdapter<std::shared_ptr<Function>>

#include <function.hpp>

template <>
class AttributeAdapter<std::shared_ptr<Function>>: public ngraph::DirectValueAccessor
{
public:
    // fields

    static constexpr DiscreteTypeInfo type_info {"AttributeAdapter<std::shared_ptr<Function>>",                                                     0};

    // construction

    AttributeAdapter(std::shared_ptr<Function>& value);

    // methods

    const DiscreteTypeInfo& get_type_info() const;
};
public:
    // methods

    virtual const VAT& get() = 0;
    virtual void set(const VAT& value) = 0;
    virtual const AT& get();
    virtual void set(const AT& value);

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

#include <aligned_buffer.hpp>

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

    static constexpr DiscreteTypeInfo type_info {             "AttributeAdapter<std::shared_ptr<runtime::AlignedBuffer>>", 0};

    // construction

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

    // methods

    const DiscreteTypeInfo& get_type_info() const;
};
public:
    // methods

    virtual const VAT& get() = 0;
    virtual void set(const VAT& value) = 0;
    virtual const AT& get();
    virtual void set(const AT& value);

class ngraph::AttributeAdapter<std::shared_ptr<Variable>>

#include <variable.hpp>

template <>
class AttributeAdapter<std::shared_ptr<Variable>>: public ngraph::DirectValueAccessor
{
public:
    // fields

    static constexpr DiscreteTypeInfo type_info {"AttributeAdapter<std::shared_ptr<Variable>>",                                                     0};

    // construction

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

    // methods

    const DiscreteTypeInfo& get_type_info() const;
};
public:
    // methods

    virtual const VAT& get() = 0;
    virtual void set(const VAT& value) = 0;
    virtual const AT& get();
    virtual void set(const AT& value);

class ngraph::AttributeAdapter<ParameterVector>

Overview

#include <parameter.hpp>

template <>
class AttributeAdapter<ParameterVector>: public ngraph::VisitorAdapter
{
public:
    // fields

    static constexpr DiscreteTypeInfo type_info {"AttributeAdapter<ParameterVector>", 0};

    // construction

    AttributeAdapter(ParameterVector& ref);

    // methods

    virtual bool visit_attributes(AttributeVisitor& visitor);
    virtual const DiscreteTypeInfo& get_type_info() const;
};

Inherited Members

public:
    // methods

    virtual const DiscreteTypeInfo& get_type_info() const = 0;
    virtual bool visit_attributes(AttributeVisitor& visitor) = 0;

Detailed Documentation

Methods

virtual const DiscreteTypeInfo& get_type_info() const

type info enables identification of the value accessor, as well as is_type and as_type.

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

#include <non_max_suppression.hpp>

template <>
class AttributeAdapter<op::v5::NonMaxSuppression::BoxEncodingType>: public ngraph::EnumAttributeAdapterBase
{
public:
    // fields

    static constexpr DiscreteTypeInfo type_info {             "AttributeAdapter<op::v5::NonMaxSuppression::BoxEncodingType>", 1};

    // construction

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

    // methods

    const DiscreteTypeInfo& get_type_info() const;
};
public:
    // methods

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

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

#include <interpolate.hpp>

template <>
class AttributeAdapter<op::v4::Interpolate::InterpolateMode>: public ngraph::EnumAttributeAdapterBase
{
public:
    // fields

    static constexpr DiscreteTypeInfo type_info {             "AttributeAdapter<op::v4::Interpolate::InterpolateMode>", 4};

    // construction

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

    // methods

    const DiscreteTypeInfo& get_type_info() const;
};
public:
    // methods

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

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

#include <interpolate.hpp>

template <>
class AttributeAdapter<op::v4::Interpolate::CoordinateTransformMode>: public ngraph::EnumAttributeAdapterBase
{
public:
    // fields

    static constexpr DiscreteTypeInfo type_info {             "AttributeAdapter<op::v4::Interpolate::CoordinateTransformMode>", 4};

    // construction

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

    // methods

    const DiscreteTypeInfo& get_type_info() const;
};
public:
    // methods

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

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

#include <round.hpp>

template <>
class AttributeAdapter<op::v5::Round::RoundMode>: public ngraph::EnumAttributeAdapterBase
{
public:
    // fields

    static constexpr DiscreteTypeInfo type_info {"AttributeAdapter<op::v5::Round::RoundMode>",                                                     5};

    // construction

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

    // methods

    const DiscreteTypeInfo& get_type_info() const;
};
public:
    // methods

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

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

#include <interpolate.hpp>

template <>
class AttributeAdapter<op::v4::Interpolate::NearestMode>: public ngraph::EnumAttributeAdapterBase
{
public:
    // fields

    static constexpr DiscreteTypeInfo type_info {             "AttributeAdapter<op::v4::Interpolate::NearestMode>", 4};

    // construction

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

    // methods

    const DiscreteTypeInfo& get_type_info() const;
};
public:
    // methods

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

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

#include <loop.hpp>

template <>
class AttributeAdapter<op::v5::Loop::SpecialBodyPorts>: public ngraph::DirectValueAccessor
{
public:
    // fields

    static constexpr DiscreteTypeInfo type_info {             "AttributeAdapter<op::v5::Loop::SpecialBodyPorts>", 0};

    // construction

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

    // methods

    const DiscreteTypeInfo& get_type_info() const;
};
public:
    // methods

    virtual const VAT& get() = 0;
    virtual void set(const VAT& value) = 0;
    virtual const AT& get();
    virtual void set(const AT& value);

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

#include <interpolate.hpp>

template <>
class AttributeAdapter<op::v4::Interpolate::ShapeCalcMode>: public ngraph::EnumAttributeAdapterBase
{
public:
    // fields

    static constexpr DiscreteTypeInfo type_info {             "AttributeAdapter<op::v4::Interpolate::ShapeCalcMode>", 4};

    // construction

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

    // methods

    const DiscreteTypeInfo& get_type_info() const;
};
public:
    // methods

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

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

#include <roi_align.hpp>

template <>
class AttributeAdapter<op::v3::ROIAlign::PoolingMode>: public ngraph::EnumAttributeAdapterBase
{
public:
    // fields

    static constexpr DiscreteTypeInfo type_info {             "AttributeAdapter<op::v3::ROIAlign::PoolingMode>", 3};

    // construction

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

    // methods

    const DiscreteTypeInfo& get_type_info() const;
};
public:
    // methods

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

class ngraph::AttributeAdapter<std::string>

Access a string as a string.

#include <attribute_adapter.hpp>

template <>
class AttributeAdapter<std::string>: public ngraph::DirectValueAccessor
{
public:
    // fields

    static constexpr DiscreteTypeInfo type_info {"AttributeAdapter<string>", 0};

    // construction

    AttributeAdapter(std::string& value);

    // methods

    const DiscreteTypeInfo& get_type_info() const;
};
public:
    // methods

    virtual const VAT& get() = 0;
    virtual void set(const VAT& value) = 0;
    virtual const AT& get();
    virtual void set(const AT& value);

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

Access a vector<float>

#include <attribute_adapter.hpp>

template <>
class AttributeAdapter<std::vector<float>>: public ngraph::DirectValueAccessor
{
public:
    // fields

    static constexpr DiscreteTypeInfo type_info {"AttributeAdapter<vector<float>>", 0};

    // construction

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

    // methods

    const DiscreteTypeInfo& get_type_info() const;
};
public:
    // methods

    virtual const VAT& get() = 0;
    virtual void set(const VAT& value) = 0;
    virtual const AT& get();
    virtual void set(const AT& value);

class ngraph::AttributeAdapter<Strides>

#include <strides.hpp>

template <>
class AttributeAdapter<Strides>: public ngraph::IndirectVectorValueAccessor
{
public:
    // fields

    static constexpr DiscreteTypeInfo type_info {"AttributeAdapter<Strides>", 0};

    // construction

    AttributeAdapter(Strides& value);

    // methods

    const DiscreteTypeInfo& get_type_info() const;
};
public:
    // methods

    virtual const VAT& get() = 0;
    virtual void set(const VAT& value) = 0;
    virtual const VAT& get();
    virtual void set(const VAT& value);
    operator AT & ();

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

Access a vector<uint8_t>

#include <attribute_adapter.hpp>

template <>
class AttributeAdapter<std::vector<uint8_t>>: public ngraph::DirectValueAccessor
{
public:
    // fields

    static constexpr DiscreteTypeInfo type_info {"AttributeAdapter<vector<uint8_t>>", 0};

    // construction

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

    // methods

    const DiscreteTypeInfo& get_type_info() const;
};
public:
    // methods

    virtual const VAT& get() = 0;
    virtual void set(const VAT& value) = 0;
    virtual const AT& get();
    virtual void set(const AT& value);

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

Access a vector<uint64_t>

#include <attribute_adapter.hpp>

template <>
class AttributeAdapter<std::vector<uint64_t>>: public ngraph::DirectValueAccessor
{
public:
    // fields

    static constexpr DiscreteTypeInfo type_info {"AttributeAdapter<vector<uint64_t>>", 0};

    // construction

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

    // methods

    const DiscreteTypeInfo& get_type_info() const;
};
public:
    // methods

    virtual const VAT& get() = 0;
    virtual void set(const VAT& value) = 0;
    virtual const AT& get();
    virtual void set(const AT& value);

class ngraph::AttributeAdapter<uint16_t>

Access a uint16_t as an int64_t.

#include <attribute_adapter.hpp>

template <>
class AttributeAdapter<uint16_t>: public ngraph::IndirectScalarValueAccessor
{
public:
    // fields

    static constexpr DiscreteTypeInfo type_info {"AttributeAdapter<uint16_t>", 0};

    // construction

    AttributeAdapter(uint16_t& value);

    // methods

    const DiscreteTypeInfo& get_type_info() const;
};
public:
    // methods

    virtual const VAT& get() = 0;
    virtual void set(const VAT& value) = 0;
    virtual const VAT& get();
    virtual void set(const VAT& value);

class ngraph::AttributeAdapter<uint64_t>

Access a uint64_t as an int64_t.

#include <attribute_adapter.hpp>

template <>
class AttributeAdapter<uint64_t>: public ngraph::IndirectScalarValueAccessor
{
public:
    // fields

    static constexpr DiscreteTypeInfo type_info {"AttributeAdapter<uint64_t>", 0};

    // construction

    AttributeAdapter(uint64_t& value);

    // methods

    const DiscreteTypeInfo& get_type_info() const;
};
public:
    // methods

    virtual const VAT& get() = 0;
    virtual void set(const VAT& value) = 0;
    virtual const VAT& get();
    virtual void set(const VAT& value);

class ngraph::AttributeAdapter<uint32_t>

Access a uint32_t as an int64_t.

#include <attribute_adapter.hpp>

template <>
class AttributeAdapter<uint32_t>: public ngraph::IndirectScalarValueAccessor
{
public:
    // fields

    static constexpr DiscreteTypeInfo type_info {"AttributeAdapter<uint32_t>", 0};

    // construction

    AttributeAdapter(uint32_t& value);

    // methods

    const DiscreteTypeInfo& get_type_info() const;
};
public:
    // methods

    virtual const VAT& get() = 0;
    virtual void set(const VAT& value) = 0;
    virtual const VAT& get();
    virtual void set(const VAT& value);

class ngraph::AttributeAdapter<uint8_t>

Access a uint8_t as an int64_t.

#include <attribute_adapter.hpp>

template <>
class AttributeAdapter<uint8_t>: public ngraph::IndirectScalarValueAccessor
{
public:
    // fields

    static constexpr DiscreteTypeInfo type_info {"AttributeAdapter<uint8_t>", 0};

    // construction

    AttributeAdapter(uint8_t& value);

    // methods

    const DiscreteTypeInfo& get_type_info() const;
};
public:
    // methods

    virtual const VAT& get() = 0;
    virtual void set(const VAT& value) = 0;
    virtual const VAT& get();
    virtual void set(const VAT& value);

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

Access a vector<double>

#include <attribute_adapter.hpp>

template <>
class AttributeAdapter<std::vector<double>>: public ngraph::DirectValueAccessor
{
public:
    // fields

    static constexpr DiscreteTypeInfo type_info {"AttributeAdapter<vector<double>>", 0};

    // construction

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

    // methods

    const DiscreteTypeInfo& get_type_info() const;
};
public:
    // methods

    virtual const VAT& get() = 0;
    virtual void set(const VAT& value) = 0;
    virtual const AT& get();
    virtual void set(const AT& value);

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

Access a vector<uint16_t>

#include <attribute_adapter.hpp>

template <>
class AttributeAdapter<std::vector<uint16_t>>: public ngraph::DirectValueAccessor
{
public:
    // fields

    static constexpr DiscreteTypeInfo type_info {"AttributeAdapter<vector<uint16_t>>", 0};

    // construction

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

    // methods

    const DiscreteTypeInfo& get_type_info() const;
};
public:
    // methods

    virtual const VAT& get() = 0;
    virtual void set(const VAT& value) = 0;
    virtual const AT& get();
    virtual void set(const AT& value);

class ngraph::AttributeAdapter<std::vector<std::shared_ptr<ngraph::op::util::SubGraphOp::OutputDescription>>>

#include <sub_graph_base.hpp>

template <>
class AttributeAdapter<std::vector<std::shared_ptr<ngraph::op::util::SubGraphOp::OutputDescription>>>: public ngraph::DirectValueAccessor
{
public:
    // fields

    static constexpr DiscreteTypeInfo type_info {             "AttributeAdapter<std::vector<std::shared_ptr<ngraph::op::util::SubGraphOp::"             "OutputDescription>>>",             0};

    // construction

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

    // methods

    const DiscreteTypeInfo& get_type_info() const;
};
public:
    // methods

    virtual const VAT& get() = 0;
    virtual void set(const VAT& value) = 0;
    virtual const AT& get();
    virtual void set(const AT& value);

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

Access a vector<int32_t>

#include <attribute_adapter.hpp>

template <>
class AttributeAdapter<std::vector<int32_t>>: public ngraph::DirectValueAccessor
{
public:
    // fields

    static constexpr DiscreteTypeInfo type_info {"AttributeAdapter<vector<int32_t>>", 0};

    // construction

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

    // methods

    const DiscreteTypeInfo& get_type_info() const;
};
public:
    // methods

    virtual const VAT& get() = 0;
    virtual void set(const VAT& value) = 0;
    virtual const AT& get();
    virtual void set(const AT& value);

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

Access a vector<int16_t>

#include <attribute_adapter.hpp>

template <>
class AttributeAdapter<std::vector<int16_t>>: public ngraph::DirectValueAccessor
{
public:
    // fields

    static constexpr DiscreteTypeInfo type_info {"AttributeAdapter<vector<int16_t>>", 0};

    // construction

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

    // methods

    const DiscreteTypeInfo& get_type_info() const;
};
public:
    // methods

    virtual const VAT& get() = 0;
    virtual void set(const VAT& value) = 0;
    virtual const AT& get();
    virtual void set(const AT& value);

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

Access a vector<string>

#include <attribute_adapter.hpp>

template <>
class AttributeAdapter<std::vector<std::string>>: public ngraph::DirectValueAccessor
{
public:
    // fields

    static constexpr DiscreteTypeInfo type_info {"AttributeAdapter<vector<string>>", 0};

    // construction

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

    // methods

    const DiscreteTypeInfo& get_type_info() const;
};
public:
    // methods

    virtual const VAT& get() = 0;
    virtual void set(const VAT& value) = 0;
    virtual const AT& get();
    virtual void set(const AT& value);

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

Access a vector<int64_t>

#include <attribute_adapter.hpp>

template <>
class AttributeAdapter<std::vector<int64_t>>: public ngraph::DirectValueAccessor
{
public:
    // fields

    static constexpr DiscreteTypeInfo type_info {"AttributeAdapter<vector<int64_t>>", 0};

    // construction

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

    // methods

    const DiscreteTypeInfo& get_type_info() const;
};
public:
    // methods

    virtual const VAT& get() = 0;
    virtual void set(const VAT& value) = 0;
    virtual const AT& get();
    virtual void set(const AT& value);

class ngraph::AttributeAdapter<std::vector<std::shared_ptr<ngraph::op::util::SubGraphOp::InputDescription>>>

#include <sub_graph_base.hpp>

template <>
class AttributeAdapter<std::vector<std::shared_ptr<ngraph::op::util::SubGraphOp::InputDescription>>>: public ngraph::DirectValueAccessor
{
public:
    // fields

    static constexpr DiscreteTypeInfo type_info {             "AttributeAdapter<std::vector<std::shared_ptr<ngraph::op::util::SubGraphOp::"             "InputDescription>>>",             0};

    // construction

    AttributeAdapter(std::vector<std::shared_ptr<ngraph::op::util::SubGraphOp::InputDescription>>& value);

    // methods

    const DiscreteTypeInfo& get_type_info() const;
};
public:
    // methods

    virtual const VAT& get() = 0;
    virtual void set(const VAT& value) = 0;
    virtual const AT& get();
    virtual void set(const AT& value);

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

Overview

Access a vector<int8_t> More…

#include <attribute_adapter.hpp>

template <>
class AttributeAdapter<std::vector<int8_t>>: public ngraph::DirectValueAccessor
{
public:
    // fields

    static constexpr DiscreteTypeInfo type_info {"AttributeAdapter<vector<int8_t>>", 0};

    // construction

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

    // methods

    const DiscreteTypeInfo& get_type_info() const;
};

Inherited Members

public:
    // methods

    virtual const VAT& get() = 0;
    virtual void set(const VAT& value) = 0;
    virtual const AT& get();
    virtual void set(const AT& value);

Detailed Documentation

Access a vector<int8_t>

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

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

#include <non_max_suppression.hpp>

template <>
class AttributeAdapter<op::v3::NonMaxSuppression::BoxEncodingType>: public ngraph::EnumAttributeAdapterBase
{
public:
    // fields

    static constexpr DiscreteTypeInfo type_info {             "AttributeAdapter<op::v3::NonMaxSuppression::BoxEncodingType>", 1};

    // construction

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

    // methods

    const DiscreteTypeInfo& get_type_info() const;
};
public:
    // methods

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

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

Access a vector<uint32_t>

#include <attribute_adapter.hpp>

template <>
class AttributeAdapter<std::vector<uint32_t>>: public ngraph::DirectValueAccessor
{
public:
    // fields

    static constexpr DiscreteTypeInfo type_info {"AttributeAdapter<vector<uint32_t>>", 0};

    // construction

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

    // methods

    const DiscreteTypeInfo& get_type_info() const;
};
public:
    // methods

    virtual const VAT& get() = 0;
    virtual void set(const VAT& value) = 0;
    virtual const AT& get();
    virtual void set(const AT& value);

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

#include <non_max_suppression.hpp>

template <>
class AttributeAdapter<op::v1::NonMaxSuppression::BoxEncodingType>: public ngraph::EnumAttributeAdapterBase
{
public:
    // fields

    static constexpr DiscreteTypeInfo type_info {             "AttributeAdapter<op::v1::NonMaxSuppression::BoxEncodingType>", 1};

    // construction

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

    // methods

    const DiscreteTypeInfo& get_type_info() const;
};
public:
    // methods

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

class ngraph::AttributeAdapter<int16_t>

Access an int16_t as an int64_t.

#include <attribute_adapter.hpp>

template <>
class AttributeAdapter<int16_t>: public ngraph::IndirectScalarValueAccessor
{
public:
    // fields

    static constexpr DiscreteTypeInfo type_info {"AttributeAdapter<int16_t>", 0};

    // construction

    AttributeAdapter(int16_t& value);

    // methods

    const DiscreteTypeInfo& get_type_info() const;
};
public:
    // methods

    virtual const VAT& get() = 0;
    virtual void set(const VAT& value) = 0;
    virtual const VAT& get();
    virtual void set(const VAT& value);

class ngraph::AttributeAdapter<float>

#include <attribute_adapter.hpp>

template <>
class AttributeAdapter<float>: public ngraph::IndirectScalarValueAccessor
{
public:
    // fields

    static constexpr DiscreteTypeInfo type_info {"AttributeAdapter<float>", 0};

    // construction

    AttributeAdapter(float& value);

    // methods

    const DiscreteTypeInfo& get_type_info() const;
};
public:
    // methods

    virtual const VAT& get() = 0;
    virtual void set(const VAT& value) = 0;
    virtual const VAT& get();
    virtual void set(const VAT& value);

class ngraph::AttributeAdapter<element::Type_t>

#include <element_type.hpp>

template <>
class AttributeAdapter<element::Type_t>: public ngraph::EnumAttributeAdapterBase
{
public:
    // fields

    static constexpr DiscreteTypeInfo type_info {"AttributeAdapter<element::Type_t>", 0};

    // construction

    AttributeAdapter(element::Type_t& value);

    // methods

    const DiscreteTypeInfo& get_type_info() const;
};
public:
    // methods

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

class ngraph::AttributeAdapter<int32_t>

Access an int32_t as an int64_t.

#include <attribute_adapter.hpp>

template <>
class AttributeAdapter<int32_t>: public ngraph::IndirectScalarValueAccessor
{
public:
    // fields

    static constexpr DiscreteTypeInfo type_info {"AttributeAdapter<int32_t>", 0};

    // construction

    AttributeAdapter(int32_t& value);

    // methods

    const DiscreteTypeInfo& get_type_info() const;
};
public:
    // methods

    virtual const VAT& get() = 0;
    virtual void set(const VAT& value) = 0;
    virtual const VAT& get();
    virtual void set(const VAT& value);

class ngraph::AttributeAdapter<NodeVector>

Overview

#include <node.hpp>

template <>
class AttributeAdapter<NodeVector>: public ngraph::VisitorAdapter
{
public:
    // fields

    static constexpr DiscreteTypeInfo type_info {"AttributeAdapter<NodeVector>", 0};

    // construction

    AttributeAdapter(NodeVector& ref);

    // methods

    virtual bool visit_attributes(AttributeVisitor& visitor);
    virtual const DiscreteTypeInfo& get_type_info() const;
};

Inherited Members

public:
    // methods

    virtual const DiscreteTypeInfo& get_type_info() const = 0;
    virtual bool visit_attributes(AttributeVisitor& visitor) = 0;

Detailed Documentation

Methods

virtual const DiscreteTypeInfo& get_type_info() const

type info enables identification of the value accessor, as well as is_type and as_type.

class ngraph::AttributeAdapter<int8_t>

Access an int8_t and an int64_t.

#include <attribute_adapter.hpp>

template <>
class AttributeAdapter<int8_t>: public ngraph::IndirectScalarValueAccessor
{
public:
    // fields

    static constexpr DiscreteTypeInfo type_info {"AttributeAdapter<int8_t>", 0};

    // construction

    AttributeAdapter(int8_t& value);

    // methods

    const DiscreteTypeInfo& get_type_info() const;
};
public:
    // methods

    virtual const VAT& get() = 0;
    virtual void set(const VAT& value) = 0;
    virtual const VAT& get();
    virtual void set(const VAT& value);

class ngraph::AttributeAdapter<op::AutoBroadcastSpec>

Overview

#include <attr_types.hpp>

template <>
class AttributeAdapter<op::AutoBroadcastSpec>: public ngraph::VisitorAdapter
{
public:
    // fields

    static constexpr DiscreteTypeInfo type_info {"AttributeAdapter<op::AutoBroadcastSpec>", 0};

    // construction

    AttributeAdapter(op::AutoBroadcastSpec& value);

    // methods

    virtual bool visit_attributes(AttributeVisitor& visitor);
    virtual const DiscreteTypeInfo& get_type_info() const;
};

Inherited Members

public:
    // methods

    virtual const DiscreteTypeInfo& get_type_info() const = 0;
    virtual bool visit_attributes(AttributeVisitor& visitor) = 0;

Detailed Documentation

Methods

virtual const DiscreteTypeInfo& get_type_info() const

type info enables identification of the value accessor, as well as is_type and as_type.

class ngraph::AttributeAdapter<op::AutoBroadcastType>

#include <attr_types.hpp>

template <>
class AttributeAdapter<op::AutoBroadcastType>: public ngraph::EnumAttributeAdapterBase
{
public:
    // fields

    static constexpr DiscreteTypeInfo type_info {"AttributeAdapter<op::AutoBroadcastType>", 0};

    // construction

    AttributeAdapter(op::AutoBroadcastType& value);

    // methods

    const DiscreteTypeInfo& get_type_info() const;
};
public:
    // methods

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

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

#include <reverse.hpp>

template <>
class AttributeAdapter<op::v1::Reverse::Mode>: public ngraph::EnumAttributeAdapterBase
{
public:
    // fields

    static constexpr DiscreteTypeInfo type_info {"AttributeAdapter<op::v1::Reverse::Mode>", 1};

    // construction

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

    // methods

    const DiscreteTypeInfo& get_type_info() const;
};
public:
    // methods

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

class ngraph::AttributeAdapter<double>

Access a double as a double.

#include <attribute_adapter.hpp>

template <>
class AttributeAdapter<double>: public ngraph::DirectValueAccessor
{
public:
    // fields

    static constexpr DiscreteTypeInfo type_info {"AttributeAdapter<double>", 0};

    // construction

    AttributeAdapter(double& value);

    // methods

    const DiscreteTypeInfo& get_type_info() const;
};
public:
    // methods

    virtual const VAT& get() = 0;
    virtual void set(const VAT& value) = 0;
    virtual const AT& get();
    virtual void set(const AT& value);

class ngraph::AttributeAdapter<AxisVector>

#include <axis_vector.hpp>

template <>
class AttributeAdapter<AxisVector>: public ngraph::IndirectVectorValueAccessor
{
public:
    // fields

    static constexpr DiscreteTypeInfo type_info {"AttributeAdapter<AxisVector>", 0};

    // construction

    AttributeAdapter(AxisVector& value);

    // methods

    const DiscreteTypeInfo& get_type_info() const;
};
public:
    // methods

    virtual const VAT& get() = 0;
    virtual void set(const VAT& value) = 0;
    virtual const VAT& get();
    virtual void set(const VAT& value);
    operator AT & ();

class ngraph::AttributeAdapter<AxisSet>

Overview

#include <axis_set.hpp>

template <>
class AttributeAdapter<AxisSet>: public ngraph::ValueAccessor
{
public:
    // fields

    static constexpr DiscreteTypeInfo type_info {"AttributeAdapter<AxisSet>", 0};

    // construction

    AttributeAdapter(AxisSet& value);

    // methods

    virtual const std::vector<int64_t>& get();
    virtual void set(const std::vector<int64_t>& value);
    const DiscreteTypeInfo& get_type_info() const;
    operator AxisSet & ();
};

Inherited Members

public:
    // methods

    virtual const VAT& get() = 0;
    virtual void set(const VAT& value) = 0;

Detailed Documentation

Methods

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

Returns the value.

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

Sets the value.

class ngraph::AttributeAdapter<element::Type>

Overview

#include <element_type.hpp>

template <>
class AttributeAdapter<element::Type>: public ngraph::ValueAccessor
{
public:
    // fields

    static constexpr DiscreteTypeInfo type_info {"AttributeAdapter<element::Type>", 0};

    // construction

    AttributeAdapter(element::Type& value);

    // methods

    virtual const std::string& get();
    virtual void set(const std::string& value);
    const DiscreteTypeInfo& get_type_info() const;
    operator element::Type & ();
};

Inherited Members

public:
    // methods

    virtual const VAT& get() = 0;
    virtual void set(const VAT& value) = 0;

Detailed Documentation

Methods

virtual const std::string& get()

Returns the value.

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

Sets the value.

class ngraph::AttributeAdapter<bool>

Access a bool as a bool.

#include <attribute_adapter.hpp>

template <>
class AttributeAdapter<bool>: public ngraph::DirectValueAccessor
{
public:
    // fields

    static constexpr DiscreteTypeInfo type_info {"AttributeAdapter<bool>", 0};

    // construction

    AttributeAdapter(bool& value);

    // methods

    const DiscreteTypeInfo& get_type_info() const;
};
public:
    // methods

    virtual const VAT& get() = 0;
    virtual void set(const VAT& value) = 0;
    virtual const AT& get();
    virtual void set(const AT& value);

class ngraph::AttributeAdapter<CoordinateDiff>

#include <coordinate_diff.hpp>

template <>
class AttributeAdapter<CoordinateDiff>: public ngraph::IndirectVectorValueAccessor
{
public:
    // fields

    static constexpr DiscreteTypeInfo type_info {"AttributeAdapter<CoordinateDiff>", 0};

    // construction

    AttributeAdapter(CoordinateDiff& value);

    // methods

    const DiscreteTypeInfo& get_type_info() const;
};
public:
    // methods

    virtual const VAT& get() = 0;
    virtual void set(const VAT& value) = 0;
    virtual const VAT& get();
    virtual void set(const VAT& value);
    operator AT & ();

class ngraph::AttributeAdapter<Coordinate>

#include <coordinate.hpp>

template <>
class AttributeAdapter<Coordinate>: public ngraph::IndirectVectorValueAccessor
{
public:
    // fields

    static constexpr DiscreteTypeInfo type_info {"AttributeAdapter<Coordinate>", 0};

    // construction

    AttributeAdapter(Coordinate& value);

    // methods

    const DiscreteTypeInfo& get_type_info() const;
};
public:
    // methods

    virtual const VAT& get() = 0;
    virtual void set(const VAT& value) = 0;
    virtual const VAT& get();
    virtual void set(const VAT& value);
    operator AT & ();

class ngraph::AttributeAdapter<op::BroadcastModeSpec>

Overview

#include <attr_types.hpp>

template <>
class AttributeAdapter<op::BroadcastModeSpec>: public ngraph::VisitorAdapter
{
public:
    // fields

    static constexpr DiscreteTypeInfo type_info {"AttributeAdapter<op::BroadcastModeSpec>", 0};

    // construction

    AttributeAdapter(op::BroadcastModeSpec& value);

    // methods

    virtual bool visit_attributes(AttributeVisitor& visitor);
    virtual const DiscreteTypeInfo& get_type_info() const;
};

Inherited Members

public:
    // methods

    virtual const DiscreteTypeInfo& get_type_info() const = 0;
    virtual bool visit_attributes(AttributeVisitor& visitor) = 0;

Detailed Documentation

Methods

virtual const DiscreteTypeInfo& get_type_info() const

type info enables identification of the value accessor, as well as is_type and as_type.

class ngraph::AttributeAdapter<int64_t>

Access an int64_t as an int64_t.

#include <attribute_adapter.hpp>

template <>
class AttributeAdapter<int64_t>: public ngraph::DirectValueAccessor
{
public:
    // fields

    static constexpr DiscreteTypeInfo type_info {"AttributeAdapter<int64_t>", 0};

    // construction

    AttributeAdapter(int64_t& value);

    // methods

    const DiscreteTypeInfo& get_type_info() const;
};
public:
    // methods

    virtual const VAT& get() = 0;
    virtual void set(const VAT& value) = 0;
    virtual const AT& get();
    virtual void set(const AT& value);

class ngraph::AttributeAdapter<op::EpsMode>

#include <attr_types.hpp>

template <>
class AttributeAdapter<op::EpsMode>: public ngraph::EnumAttributeAdapterBase
{
public:
    // fields

    static constexpr DiscreteTypeInfo type_info {"AttributeAdapter<op::EpsMode>", 0};

    // construction

    AttributeAdapter(op::EpsMode& value);

    // methods

    const DiscreteTypeInfo& get_type_info() const;
};
public:
    // methods

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

class ngraph::AttributeAdapter<op::TopKSortType>

#include <attr_types.hpp>

template <>
class AttributeAdapter<op::TopKSortType>: public ngraph::EnumAttributeAdapterBase
{
public:
    // fields

    static constexpr DiscreteTypeInfo type_info {"AttributeAdapter<op::TopKSortType>", 0};

    // construction

    AttributeAdapter(op::TopKSortType& value);

    // methods

    const DiscreteTypeInfo& get_type_info() const;
};
public:
    // methods

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

class ngraph::AttributeAdapter<op::TopKMode>

#include <attr_types.hpp>

template <>
class AttributeAdapter<op::TopKMode>: public ngraph::EnumAttributeAdapterBase
{
public:
    // fields

    static constexpr DiscreteTypeInfo type_info {"AttributeAdapter<op::TopKMode>", 1};

    // construction

    AttributeAdapter(op::TopKMode& value);

    // methods

    const DiscreteTypeInfo& get_type_info() const;
};
public:
    // methods

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

class ngraph::AttributeAdapter<op::RoundingType>

#include <attr_types.hpp>

template <>
class AttributeAdapter<op::RoundingType>: public ngraph::EnumAttributeAdapterBase
{
public:
    // fields

    static constexpr DiscreteTypeInfo type_info {"AttributeAdapter<op::RoundingType>", 0};

    // construction

    AttributeAdapter(op::RoundingType& value);

    // methods

    const DiscreteTypeInfo& get_type_info() const;
};
public:
    // methods

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

class ngraph::AttributeAdapter<op::BroadcastType>

#include <attr_types.hpp>

template <>
class AttributeAdapter<op::BroadcastType>: public ngraph::EnumAttributeAdapterBase
{
public:
    // fields

    static constexpr DiscreteTypeInfo type_info {"AttributeAdapter<op::BroadcastType>", 0};

    // construction

    AttributeAdapter(op::BroadcastType& value);

    // methods

    const DiscreteTypeInfo& get_type_info() const;
};
public:
    // methods

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

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

#include <space_to_depth.hpp>

template <>
class AttributeAdapter<op::v0::SpaceToDepth::SpaceToDepthMode>: public ngraph::EnumAttributeAdapterBase
{
public:
    // fields

    static constexpr DiscreteTypeInfo type_info {             "AttributeAdapter<op::v0::SpaceToDepth::SpaceToDepthMode>", 0};

    // construction

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

    // methods

    const DiscreteTypeInfo& get_type_info() const;
};
public:
    // methods

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

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

#include <interpolate.hpp>

template <>
class AttributeAdapter<op::v0::Interpolate::InterpolateMode>: public ngraph::EnumAttributeAdapterBase
{
public:
    // fields

    static constexpr DiscreteTypeInfo type_info {             "AttributeAdapter<op::v0::Interpolate::InterpolateMode>", 0};

    // construction

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

    // methods

    const DiscreteTypeInfo& get_type_info() const;
};
public:
    // methods

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

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

#include <binary_convolution.hpp>

template <>
class AttributeAdapter<op::v1::BinaryConvolution::BinaryConvolutionMode>: public ngraph::EnumAttributeAdapterBase
{
public:
    // fields

    static constexpr DiscreteTypeInfo type_info {             "AttributeAdapter<op::v1::BinaryConvolution::BinaryConvolutionMode>", 0};

    // construction

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

    // methods

    const DiscreteTypeInfo& get_type_info() const;
};
public:
    // methods

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

class ngraph::AttributeAdapter<op::RecurrentSequenceDirection>

#include <attr_types.hpp>

template <>
class AttributeAdapter<op::RecurrentSequenceDirection>: public ngraph::EnumAttributeAdapterBase
{
public:
    // fields

    static constexpr DiscreteTypeInfo type_info {             "AttributeAdapter<op::RecurrentSequenceDirection>", 1};

    // construction

    AttributeAdapter(op::RecurrentSequenceDirection& value);

    // methods

    const DiscreteTypeInfo& get_type_info() const;
};
public:
    // methods

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

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

#include <depth_to_space.hpp>

template <>
class AttributeAdapter<op::v0::DepthToSpace::DepthToSpaceMode>: public ngraph::EnumAttributeAdapterBase
{
public:
    // fields

    static constexpr DiscreteTypeInfo type_info {             "AttributeAdapter<op::v0::DepthToSpace::DepthToSpaceMode>", 0};

    // construction

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

    // methods

    const DiscreteTypeInfo& get_type_info() const;
};
public:
    // methods

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

class ngraph::AttributeAdapter<op::PadMode>

#include <attr_types.hpp>

template <>
class AttributeAdapter<op::PadMode>: public ngraph::EnumAttributeAdapterBase
{
public:
    // fields

    static constexpr DiscreteTypeInfo type_info {"AttributeAdapter<op::PadMode>", 0};

    // construction

    AttributeAdapter(op::PadMode& value);

    // methods

    const DiscreteTypeInfo& get_type_info() const;
};
public:
    // methods

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

class ngraph::AttributeAdapter<op::GeluApproximationMode>

#include <gelu.hpp>

template <>
class AttributeAdapter<op::GeluApproximationMode>: public ngraph::EnumAttributeAdapterBase
{
public:
    // fields

    static constexpr DiscreteTypeInfo type_info {"AttributeAdapter<op::GeluApproximationMode>",                                                     0};

    // construction

    AttributeAdapter(op::GeluApproximationMode& value);

    // methods

    const DiscreteTypeInfo& get_type_info() const;
};
public:
    // methods

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

class ngraph::AttributeAdapter<op::FrameworkNodeAttrs>

#include <framework_node.hpp>

template <>
class AttributeAdapter<op::FrameworkNodeAttrs>: public ngraph::DirectValueAccessor
{
public:
    // fields

    static constexpr DiscreteTypeInfo type_info {"AttributeAdapter<FrameworkNodeAttr>", 0};

    // construction

    AttributeAdapter(op::FrameworkNodeAttrs& value);

    // methods

    const DiscreteTypeInfo& get_type_info() const;
};
public:
    // methods

    virtual const VAT& get() = 0;
    virtual void set(const VAT& value) = 0;
    virtual const AT& get();
    virtual void set(const AT& value);

class ngraph::AttributeAdapter<op::PadType>

#include <attr_types.hpp>

template <>
class AttributeAdapter<op::PadType>: public ngraph::EnumAttributeAdapterBase
{
public:
    // fields

    static constexpr DiscreteTypeInfo type_info {"AttributeAdapter<op::PadType>", 0};

    // construction

    AttributeAdapter(op::PadType& value);

    // methods

    const DiscreteTypeInfo& get_type_info() const;
};
public:
    // methods

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

class ngraph::AttributeAdapter<op::MVNEpsMode>

#include <mvn.hpp>

template <>
class AttributeAdapter<op::MVNEpsMode>: public ngraph::EnumAttributeAdapterBase
{
public:
    // fields

    static constexpr DiscreteTypeInfo type_info {"AttributeAdapter<op::MVNEpsMode>", 0};

    // construction

    AttributeAdapter(op::MVNEpsMode& value);

    // methods

    const DiscreteTypeInfo& get_type_info() const;
};
public:
    // methods

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

class ngraph::AttributeAdapter<op::LSTMWeightsFormat>

#include <lstm_cell.hpp>

template <>
class AttributeAdapter<op::LSTMWeightsFormat>: public ngraph::EnumAttributeAdapterBase
{
public:
    // fields

    static constexpr DiscreteTypeInfo type_info {"AttributeAdapter<op::LSTMWeightsFormat>", 1};

    // construction

    AttributeAdapter(op::LSTMWeightsFormat& value);

    // methods

    const DiscreteTypeInfo& get_type_info() const;
};
public:
    // methods

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