Class: Com::Vmware::Cis::Tagging::CategoryModel

Inherits:
VAPI::Bindings::VapiStruct
  • Object
show all
Defined in:
/build/mts/release/bora-4571906/build/sdk/aggregated-bindings/ruby/com/vmware/cis/tagging.rb

Overview

The ``Com::Vmware::Cis::Tagging::CategoryModel`` class defines a category that is used to group one or more tags.

Defined Under Namespace

Classes: Cardinality

Instance Attribute Summary (collapse)

Class Method Summary (collapse)

Instance Method Summary (collapse)

Constructor Details

- (CategoryModel) initialize(ruby_values = nil, struct_value = nil)

Constructs a new instance.

Parameters:

  • ruby_values (Hash) (defaults to: nil) —

    a map of initial property values (optional)

  • struct_value (VAPI::Data::StructValue) (defaults to: nil) —

    a raw StructValue from the wire (optional) 



1378
1379
1380
 
# File '/build/mts/release/bora-4571906/build/sdk/aggregated-bindings/ruby/com/vmware/cis/tagging.rb', line 1378

def initialize(ruby_values=nil, struct_value=nil)
    super(self.class.binding_type, ruby_values, struct_value)
end

Instance Attribute Details

- (Set<String>) associable_types

The types of objects that the tags in this category can be attached to. If the set is empty, then tags can be attached to all types of objects. This field works only for objects that reside in Inventory Service (IS). For non IS objects, this check is not performed today and hence a tag can be attached to any non IS object.

Returns:

  • (Set<String>) 


1345
1346
1347
1348
1349
1350
1351
1352
1353
1354
1355
1356
1357
1358
1359
1360
1361
1362
1363
1364
1365
1366
1367
1368
1369
1370
1371
1372
1373
1374
1375
1376
1377
1378
1379
1380
1381
1382
1383
1384
1385
1386
1387
1388
1389
1390
1391
1392
1393
1394
1395
1396
1397
1398
1399
1400
1401
1402
1403
1404
1405
1406
1407
1408
1409
1410
1411
1412
1413
1414
1415
1416
1417
1418
1419
1420
1421
1422
1423
1424
1425
1426
1427
1428
1429
1430
1431
1432
1433
1434
1435
1436
1437
1438
1439
1440
 
# File '/build/mts/release/bora-4571906/build/sdk/aggregated-bindings/ruby/com/vmware/cis/tagging.rb', line 1345

class CategoryModel < VAPI::Bindings::VapiStruct

    class << self
        # Holds (gets or creates) the binding type metadata for this structure type.
        # @scope class
        # @return [VAPI::Bindings::StructType] the binding type
        def binding_type
            @binding_type ||= VAPI::Bindings::StructType.new(
                'com.vmware.cis.tagging.category_model',
                {
                    'id' => VAPI::Bindings::IdType.new(resource_types='com.vmware.cis.tagging.Category'),
                    'name' => VAPI::Bindings::StringType.instance,
                    'description' => VAPI::Bindings::StringType.instance,
                    'cardinality' => VAPI::Bindings::ReferenceType.new('Com::Vmware::Cis::Tagging::CategoryModel::Cardinality'),
                    'associable_types' => VAPI::Bindings::SetType.new(VAPI::Bindings::StringType.instance),
                    'used_by' => VAPI::Bindings::SetType.new(VAPI::Bindings::StringType.instance),
                },
                CategoryModel,
                true,
                ["id"])
        end
    end

    attr_accessor :id,
                  :name,
                  :description,
                  :cardinality,
                  :associable_types,
                  :used_by

    # Constructs a new instance.
    # @param ruby_values [Hash] a map of initial property values (optional)
    # @param struct_value [VAPI::Data::StructValue] a raw StructValue from the wire (optional)
    def initialize(ruby_values=nil, struct_value=nil)
        super(self.class.binding_type, ruby_values, struct_value)
    end


    # The  ``Com::Vmware::Cis::Tagging::CategoryModel::Cardinality``   enumerated type  defines the number of tags in a category that can be assigned to an object.
    # @!attribute [rw] single
    #     @return [Com::Vmware::Cis::Tagging::CategoryModel::Cardinality]
    #     An object can only be assigned one of the tags in this category. For example, if a category is "Operating System", then different tags of this category would be "Windows", "Linux", and so on. In this case a VM object can be assigned only one of these tags and hence the cardinality of the associated category here is single.
    # @!attribute [rw] multiple
    #     @return [Com::Vmware::Cis::Tagging::CategoryModel::Cardinality]
    #     An object can be assigned several of the tags in this category. For example, if a category is "Server", then different tags of this category would be "AppServer", "DatabaseServer" and so on. In this case a VM object can be assigned more than one of the above tags and hence the cardinality of the associated category here is multiple.
    class Cardinality < VAPI::Bindings::VapiEnum

        class << self
            # Holds (gets or creates) the binding type metadata for this enumeration type.
            # @scope class
            # @return [VAPI::Bindings::EnumType] the binding type
            def binding_type
                @binding_type ||= VAPI::Bindings::EnumType.new(
                    'com.vmware.cis.tagging.category_model.cardinality',
                    Cardinality)
            end

            # Converts from a string value (perhaps off the wire) to an instance
            # of this enum type.
            # @param value [String] the actual value of the enum instance
            # @return [Cardinality] the instance found for the value, otherwise
            #         an unknown instance will be built for the value
            def from_string(value)
                begin
                    const_get(value)
                rescue NameError
                    Cardinality.new('UNKNOWN', value)
                end
            end
        end

        private

        # Constructs a new instance.
        # @param value [String] the actual value of the enum instance
        # @param unknown [String] the unknown value when value is 'UKNOWN'
        def initialize(value, unknown=nil)
            super(self.class.binding_type, value, unknown)
        end

        public

        # @!attribute [rw] single
        #     @return [Com::Vmware::Cis::Tagging::CategoryModel::Cardinality]
        #     An object can only be assigned one of the tags in this category. For example, if a category is "Operating System", then different tags of this category would be "Windows", "Linux", and so on. In this case a VM object can be assigned only one of these tags and hence the cardinality of the associated category here is single.
        SINGLE = Cardinality.new('SINGLE')

        # @!attribute [rw] multiple
        #     @return [Com::Vmware::Cis::Tagging::CategoryModel::Cardinality]
        #     An object can be assigned several of the tags in this category. For example, if a category is "Server", then different tags of this category would be "AppServer", "DatabaseServer" and so on. In this case a VM object can be assigned more than one of the above tags and hence the cardinality of the associated category here is multiple.
        MULTIPLE = Cardinality.new('MULTIPLE')

    end


end

- (Com::Vmware::Cis::Tagging::CategoryModel::Cardinality) cardinality

The associated cardinality ( ``SINGLE``, ``MULTIPLE`` ) of the category.

Returns:



1345
1346
1347
1348
1349
1350
1351
1352
1353
1354
1355
1356
1357
1358
1359
1360
1361
1362
1363
1364
1365
1366
1367
1368
1369
1370
1371
1372
1373
1374
1375
1376
1377
1378
1379
1380
1381
1382
1383
1384
1385
1386
1387
1388
1389
1390
1391
1392
1393
1394
1395
1396
1397
1398
1399
1400
1401
1402
1403
1404
1405
1406
1407
1408
1409
1410
1411
1412
1413
1414
1415
1416
1417
1418
1419
1420
1421
1422
1423
1424
1425
1426
1427
1428
1429
1430
1431
1432
1433
1434
1435
1436
1437
1438
1439
1440
 
# File '/build/mts/release/bora-4571906/build/sdk/aggregated-bindings/ruby/com/vmware/cis/tagging.rb', line 1345

class CategoryModel < VAPI::Bindings::VapiStruct

    class << self
        # Holds (gets or creates) the binding type metadata for this structure type.
        # @scope class
        # @return [VAPI::Bindings::StructType] the binding type
        def binding_type
            @binding_type ||= VAPI::Bindings::StructType.new(
                'com.vmware.cis.tagging.category_model',
                {
                    'id' => VAPI::Bindings::IdType.new(resource_types='com.vmware.cis.tagging.Category'),
                    'name' => VAPI::Bindings::StringType.instance,
                    'description' => VAPI::Bindings::StringType.instance,
                    'cardinality' => VAPI::Bindings::ReferenceType.new('Com::Vmware::Cis::Tagging::CategoryModel::Cardinality'),
                    'associable_types' => VAPI::Bindings::SetType.new(VAPI::Bindings::StringType.instance),
                    'used_by' => VAPI::Bindings::SetType.new(VAPI::Bindings::StringType.instance),
                },
                CategoryModel,
                true,
                ["id"])
        end
    end

    attr_accessor :id,
                  :name,
                  :description,
                  :cardinality,
                  :associable_types,
                  :used_by

    # Constructs a new instance.
    # @param ruby_values [Hash] a map of initial property values (optional)
    # @param struct_value [VAPI::Data::StructValue] a raw StructValue from the wire (optional)
    def initialize(ruby_values=nil, struct_value=nil)
        super(self.class.binding_type, ruby_values, struct_value)
    end


    # The  ``Com::Vmware::Cis::Tagging::CategoryModel::Cardinality``   enumerated type  defines the number of tags in a category that can be assigned to an object.
    # @!attribute [rw] single
    #     @return [Com::Vmware::Cis::Tagging::CategoryModel::Cardinality]
    #     An object can only be assigned one of the tags in this category. For example, if a category is "Operating System", then different tags of this category would be "Windows", "Linux", and so on. In this case a VM object can be assigned only one of these tags and hence the cardinality of the associated category here is single.
    # @!attribute [rw] multiple
    #     @return [Com::Vmware::Cis::Tagging::CategoryModel::Cardinality]
    #     An object can be assigned several of the tags in this category. For example, if a category is "Server", then different tags of this category would be "AppServer", "DatabaseServer" and so on. In this case a VM object can be assigned more than one of the above tags and hence the cardinality of the associated category here is multiple.
    class Cardinality < VAPI::Bindings::VapiEnum

        class << self
            # Holds (gets or creates) the binding type metadata for this enumeration type.
            # @scope class
            # @return [VAPI::Bindings::EnumType] the binding type
            def binding_type
                @binding_type ||= VAPI::Bindings::EnumType.new(
                    'com.vmware.cis.tagging.category_model.cardinality',
                    Cardinality)
            end

            # Converts from a string value (perhaps off the wire) to an instance
            # of this enum type.
            # @param value [String] the actual value of the enum instance
            # @return [Cardinality] the instance found for the value, otherwise
            #         an unknown instance will be built for the value
            def from_string(value)
                begin
                    const_get(value)
                rescue NameError
                    Cardinality.new('UNKNOWN', value)
                end
            end
        end

        private

        # Constructs a new instance.
        # @param value [String] the actual value of the enum instance
        # @param unknown [String] the unknown value when value is 'UKNOWN'
        def initialize(value, unknown=nil)
            super(self.class.binding_type, value, unknown)
        end

        public

        # @!attribute [rw] single
        #     @return [Com::Vmware::Cis::Tagging::CategoryModel::Cardinality]
        #     An object can only be assigned one of the tags in this category. For example, if a category is "Operating System", then different tags of this category would be "Windows", "Linux", and so on. In this case a VM object can be assigned only one of these tags and hence the cardinality of the associated category here is single.
        SINGLE = Cardinality.new('SINGLE')

        # @!attribute [rw] multiple
        #     @return [Com::Vmware::Cis::Tagging::CategoryModel::Cardinality]
        #     An object can be assigned several of the tags in this category. For example, if a category is "Server", then different tags of this category would be "AppServer", "DatabaseServer" and so on. In this case a VM object can be assigned more than one of the above tags and hence the cardinality of the associated category here is multiple.
        MULTIPLE = Cardinality.new('MULTIPLE')

    end


end

- (String) description

The description of the category.

Returns:

  • (String) 


1345
1346
1347
1348
1349
1350
1351
1352
1353
1354
1355
1356
1357
1358
1359
1360
1361
1362
1363
1364
1365
1366
1367
1368
1369
1370
1371
1372
1373
1374
1375
1376
1377
1378
1379
1380
1381
1382
1383
1384
1385
1386
1387
1388
1389
1390
1391
1392
1393
1394
1395
1396
1397
1398
1399
1400
1401
1402
1403
1404
1405
1406
1407
1408
1409
1410
1411
1412
1413
1414
1415
1416
1417
1418
1419
1420
1421
1422
1423
1424
1425
1426
1427
1428
1429
1430
1431
1432
1433
1434
1435
1436
1437
1438
1439
1440
 
# File '/build/mts/release/bora-4571906/build/sdk/aggregated-bindings/ruby/com/vmware/cis/tagging.rb', line 1345

class CategoryModel < VAPI::Bindings::VapiStruct

    class << self
        # Holds (gets or creates) the binding type metadata for this structure type.
        # @scope class
        # @return [VAPI::Bindings::StructType] the binding type
        def binding_type
            @binding_type ||= VAPI::Bindings::StructType.new(
                'com.vmware.cis.tagging.category_model',
                {
                    'id' => VAPI::Bindings::IdType.new(resource_types='com.vmware.cis.tagging.Category'),
                    'name' => VAPI::Bindings::StringType.instance,
                    'description' => VAPI::Bindings::StringType.instance,
                    'cardinality' => VAPI::Bindings::ReferenceType.new('Com::Vmware::Cis::Tagging::CategoryModel::Cardinality'),
                    'associable_types' => VAPI::Bindings::SetType.new(VAPI::Bindings::StringType.instance),
                    'used_by' => VAPI::Bindings::SetType.new(VAPI::Bindings::StringType.instance),
                },
                CategoryModel,
                true,
                ["id"])
        end
    end

    attr_accessor :id,
                  :name,
                  :description,
                  :cardinality,
                  :associable_types,
                  :used_by

    # Constructs a new instance.
    # @param ruby_values [Hash] a map of initial property values (optional)
    # @param struct_value [VAPI::Data::StructValue] a raw StructValue from the wire (optional)
    def initialize(ruby_values=nil, struct_value=nil)
        super(self.class.binding_type, ruby_values, struct_value)
    end


    # The  ``Com::Vmware::Cis::Tagging::CategoryModel::Cardinality``   enumerated type  defines the number of tags in a category that can be assigned to an object.
    # @!attribute [rw] single
    #     @return [Com::Vmware::Cis::Tagging::CategoryModel::Cardinality]
    #     An object can only be assigned one of the tags in this category. For example, if a category is "Operating System", then different tags of this category would be "Windows", "Linux", and so on. In this case a VM object can be assigned only one of these tags and hence the cardinality of the associated category here is single.
    # @!attribute [rw] multiple
    #     @return [Com::Vmware::Cis::Tagging::CategoryModel::Cardinality]
    #     An object can be assigned several of the tags in this category. For example, if a category is "Server", then different tags of this category would be "AppServer", "DatabaseServer" and so on. In this case a VM object can be assigned more than one of the above tags and hence the cardinality of the associated category here is multiple.
    class Cardinality < VAPI::Bindings::VapiEnum

        class << self
            # Holds (gets or creates) the binding type metadata for this enumeration type.
            # @scope class
            # @return [VAPI::Bindings::EnumType] the binding type
            def binding_type
                @binding_type ||= VAPI::Bindings::EnumType.new(
                    'com.vmware.cis.tagging.category_model.cardinality',
                    Cardinality)
            end

            # Converts from a string value (perhaps off the wire) to an instance
            # of this enum type.
            # @param value [String] the actual value of the enum instance
            # @return [Cardinality] the instance found for the value, otherwise
            #         an unknown instance will be built for the value
            def from_string(value)
                begin
                    const_get(value)
                rescue NameError
                    Cardinality.new('UNKNOWN', value)
                end
            end
        end

        private

        # Constructs a new instance.
        # @param value [String] the actual value of the enum instance
        # @param unknown [String] the unknown value when value is 'UKNOWN'
        def initialize(value, unknown=nil)
            super(self.class.binding_type, value, unknown)
        end

        public

        # @!attribute [rw] single
        #     @return [Com::Vmware::Cis::Tagging::CategoryModel::Cardinality]
        #     An object can only be assigned one of the tags in this category. For example, if a category is "Operating System", then different tags of this category would be "Windows", "Linux", and so on. In this case a VM object can be assigned only one of these tags and hence the cardinality of the associated category here is single.
        SINGLE = Cardinality.new('SINGLE')

        # @!attribute [rw] multiple
        #     @return [Com::Vmware::Cis::Tagging::CategoryModel::Cardinality]
        #     An object can be assigned several of the tags in this category. For example, if a category is "Server", then different tags of this category would be "AppServer", "DatabaseServer" and so on. In this case a VM object can be assigned more than one of the above tags and hence the cardinality of the associated category here is multiple.
        MULTIPLE = Cardinality.new('MULTIPLE')

    end


end

- (String) id

The unique identifier of the category.

Returns:

  • (String) 


1345
1346
1347
1348
1349
1350
1351
1352
1353
1354
1355
1356
1357
1358
1359
1360
1361
1362
1363
1364
1365
1366
1367
1368
1369
1370
1371
1372
1373
1374
1375
1376
1377
1378
1379
1380
1381
1382
1383
1384
1385
1386
1387
1388
1389
1390
1391
1392
1393
1394
1395
1396
1397
1398
1399
1400
1401
1402
1403
1404
1405
1406
1407
1408
1409
1410
1411
1412
1413
1414
1415
1416
1417
1418
1419
1420
1421
1422
1423
1424
1425
1426
1427
1428
1429
1430
1431
1432
1433
1434
1435
1436
1437
1438
1439
1440
 
# File '/build/mts/release/bora-4571906/build/sdk/aggregated-bindings/ruby/com/vmware/cis/tagging.rb', line 1345

class CategoryModel < VAPI::Bindings::VapiStruct

    class << self
        # Holds (gets or creates) the binding type metadata for this structure type.
        # @scope class
        # @return [VAPI::Bindings::StructType] the binding type
        def binding_type
            @binding_type ||= VAPI::Bindings::StructType.new(
                'com.vmware.cis.tagging.category_model',
                {
                    'id' => VAPI::Bindings::IdType.new(resource_types='com.vmware.cis.tagging.Category'),
                    'name' => VAPI::Bindings::StringType.instance,
                    'description' => VAPI::Bindings::StringType.instance,
                    'cardinality' => VAPI::Bindings::ReferenceType.new('Com::Vmware::Cis::Tagging::CategoryModel::Cardinality'),
                    'associable_types' => VAPI::Bindings::SetType.new(VAPI::Bindings::StringType.instance),
                    'used_by' => VAPI::Bindings::SetType.new(VAPI::Bindings::StringType.instance),
                },
                CategoryModel,
                true,
                ["id"])
        end
    end

    attr_accessor :id,
                  :name,
                  :description,
                  :cardinality,
                  :associable_types,
                  :used_by

    # Constructs a new instance.
    # @param ruby_values [Hash] a map of initial property values (optional)
    # @param struct_value [VAPI::Data::StructValue] a raw StructValue from the wire (optional)
    def initialize(ruby_values=nil, struct_value=nil)
        super(self.class.binding_type, ruby_values, struct_value)
    end


    # The  ``Com::Vmware::Cis::Tagging::CategoryModel::Cardinality``   enumerated type  defines the number of tags in a category that can be assigned to an object.
    # @!attribute [rw] single
    #     @return [Com::Vmware::Cis::Tagging::CategoryModel::Cardinality]
    #     An object can only be assigned one of the tags in this category. For example, if a category is "Operating System", then different tags of this category would be "Windows", "Linux", and so on. In this case a VM object can be assigned only one of these tags and hence the cardinality of the associated category here is single.
    # @!attribute [rw] multiple
    #     @return [Com::Vmware::Cis::Tagging::CategoryModel::Cardinality]
    #     An object can be assigned several of the tags in this category. For example, if a category is "Server", then different tags of this category would be "AppServer", "DatabaseServer" and so on. In this case a VM object can be assigned more than one of the above tags and hence the cardinality of the associated category here is multiple.
    class Cardinality < VAPI::Bindings::VapiEnum

        class << self
            # Holds (gets or creates) the binding type metadata for this enumeration type.
            # @scope class
            # @return [VAPI::Bindings::EnumType] the binding type
            def binding_type
                @binding_type ||= VAPI::Bindings::EnumType.new(
                    'com.vmware.cis.tagging.category_model.cardinality',
                    Cardinality)
            end

            # Converts from a string value (perhaps off the wire) to an instance
            # of this enum type.
            # @param value [String] the actual value of the enum instance
            # @return [Cardinality] the instance found for the value, otherwise
            #         an unknown instance will be built for the value
            def from_string(value)
                begin
                    const_get(value)
                rescue NameError
                    Cardinality.new('UNKNOWN', value)
                end
            end
        end

        private

        # Constructs a new instance.
        # @param value [String] the actual value of the enum instance
        # @param unknown [String] the unknown value when value is 'UKNOWN'
        def initialize(value, unknown=nil)
            super(self.class.binding_type, value, unknown)
        end

        public

        # @!attribute [rw] single
        #     @return [Com::Vmware::Cis::Tagging::CategoryModel::Cardinality]
        #     An object can only be assigned one of the tags in this category. For example, if a category is "Operating System", then different tags of this category would be "Windows", "Linux", and so on. In this case a VM object can be assigned only one of these tags and hence the cardinality of the associated category here is single.
        SINGLE = Cardinality.new('SINGLE')

        # @!attribute [rw] multiple
        #     @return [Com::Vmware::Cis::Tagging::CategoryModel::Cardinality]
        #     An object can be assigned several of the tags in this category. For example, if a category is "Server", then different tags of this category would be "AppServer", "DatabaseServer" and so on. In this case a VM object can be assigned more than one of the above tags and hence the cardinality of the associated category here is multiple.
        MULTIPLE = Cardinality.new('MULTIPLE')

    end


end

- (String) name

The display name of the category.

Returns:

  • (String) 


1345
1346
1347
1348
1349
1350
1351
1352
1353
1354
1355
1356
1357
1358
1359
1360
1361
1362
1363
1364
1365
1366
1367
1368
1369
1370
1371
1372
1373
1374
1375
1376
1377
1378
1379
1380
1381
1382
1383
1384
1385
1386
1387
1388
1389
1390
1391
1392
1393
1394
1395
1396
1397
1398
1399
1400
1401
1402
1403
1404
1405
1406
1407
1408
1409
1410
1411
1412
1413
1414
1415
1416
1417
1418
1419
1420
1421
1422
1423
1424
1425
1426
1427
1428
1429
1430
1431
1432
1433
1434
1435
1436
1437
1438
1439
1440
 
# File '/build/mts/release/bora-4571906/build/sdk/aggregated-bindings/ruby/com/vmware/cis/tagging.rb', line 1345

class CategoryModel < VAPI::Bindings::VapiStruct

    class << self
        # Holds (gets or creates) the binding type metadata for this structure type.
        # @scope class
        # @return [VAPI::Bindings::StructType] the binding type
        def binding_type
            @binding_type ||= VAPI::Bindings::StructType.new(
                'com.vmware.cis.tagging.category_model',
                {
                    'id' => VAPI::Bindings::IdType.new(resource_types='com.vmware.cis.tagging.Category'),
                    'name' => VAPI::Bindings::StringType.instance,
                    'description' => VAPI::Bindings::StringType.instance,
                    'cardinality' => VAPI::Bindings::ReferenceType.new('Com::Vmware::Cis::Tagging::CategoryModel::Cardinality'),
                    'associable_types' => VAPI::Bindings::SetType.new(VAPI::Bindings::StringType.instance),
                    'used_by' => VAPI::Bindings::SetType.new(VAPI::Bindings::StringType.instance),
                },
                CategoryModel,
                true,
                ["id"])
        end
    end

    attr_accessor :id,
                  :name,
                  :description,
                  :cardinality,
                  :associable_types,
                  :used_by

    # Constructs a new instance.
    # @param ruby_values [Hash] a map of initial property values (optional)
    # @param struct_value [VAPI::Data::StructValue] a raw StructValue from the wire (optional)
    def initialize(ruby_values=nil, struct_value=nil)
        super(self.class.binding_type, ruby_values, struct_value)
    end


    # The  ``Com::Vmware::Cis::Tagging::CategoryModel::Cardinality``   enumerated type  defines the number of tags in a category that can be assigned to an object.
    # @!attribute [rw] single
    #     @return [Com::Vmware::Cis::Tagging::CategoryModel::Cardinality]
    #     An object can only be assigned one of the tags in this category. For example, if a category is "Operating System", then different tags of this category would be "Windows", "Linux", and so on. In this case a VM object can be assigned only one of these tags and hence the cardinality of the associated category here is single.
    # @!attribute [rw] multiple
    #     @return [Com::Vmware::Cis::Tagging::CategoryModel::Cardinality]
    #     An object can be assigned several of the tags in this category. For example, if a category is "Server", then different tags of this category would be "AppServer", "DatabaseServer" and so on. In this case a VM object can be assigned more than one of the above tags and hence the cardinality of the associated category here is multiple.
    class Cardinality < VAPI::Bindings::VapiEnum

        class << self
            # Holds (gets or creates) the binding type metadata for this enumeration type.
            # @scope class
            # @return [VAPI::Bindings::EnumType] the binding type
            def binding_type
                @binding_type ||= VAPI::Bindings::EnumType.new(
                    'com.vmware.cis.tagging.category_model.cardinality',
                    Cardinality)
            end

            # Converts from a string value (perhaps off the wire) to an instance
            # of this enum type.
            # @param value [String] the actual value of the enum instance
            # @return [Cardinality] the instance found for the value, otherwise
            #         an unknown instance will be built for the value
            def from_string(value)
                begin
                    const_get(value)
                rescue NameError
                    Cardinality.new('UNKNOWN', value)
                end
            end
        end

        private

        # Constructs a new instance.
        # @param value [String] the actual value of the enum instance
        # @param unknown [String] the unknown value when value is 'UKNOWN'
        def initialize(value, unknown=nil)
            super(self.class.binding_type, value, unknown)
        end

        public

        # @!attribute [rw] single
        #     @return [Com::Vmware::Cis::Tagging::CategoryModel::Cardinality]
        #     An object can only be assigned one of the tags in this category. For example, if a category is "Operating System", then different tags of this category would be "Windows", "Linux", and so on. In this case a VM object can be assigned only one of these tags and hence the cardinality of the associated category here is single.
        SINGLE = Cardinality.new('SINGLE')

        # @!attribute [rw] multiple
        #     @return [Com::Vmware::Cis::Tagging::CategoryModel::Cardinality]
        #     An object can be assigned several of the tags in this category. For example, if a category is "Server", then different tags of this category would be "AppServer", "DatabaseServer" and so on. In this case a VM object can be assigned more than one of the above tags and hence the cardinality of the associated category here is multiple.
        MULTIPLE = Cardinality.new('MULTIPLE')

    end


end

- (Set<String>) used_by

The set of users that can use this category. To add users to this, you need to have the edit privilege on the category. Similarly, to unsubscribe from this category, you need the edit privilege on the category. You should not modify other users subscription from this set .

Returns:

  • (Set<String>) 


1345
1346
1347
1348
1349
1350
1351
1352
1353
1354
1355
1356
1357
1358
1359
1360
1361
1362
1363
1364
1365
1366
1367
1368
1369
1370
1371
1372
1373
1374
1375
1376
1377
1378
1379
1380
1381
1382
1383
1384
1385
1386
1387
1388
1389
1390
1391
1392
1393
1394
1395
1396
1397
1398
1399
1400
1401
1402
1403
1404
1405
1406
1407
1408
1409
1410
1411
1412
1413
1414
1415
1416
1417
1418
1419
1420
1421
1422
1423
1424
1425
1426
1427
1428
1429
1430
1431
1432
1433
1434
1435
1436
1437
1438
1439
1440
 
# File '/build/mts/release/bora-4571906/build/sdk/aggregated-bindings/ruby/com/vmware/cis/tagging.rb', line 1345

class CategoryModel < VAPI::Bindings::VapiStruct

    class << self
        # Holds (gets or creates) the binding type metadata for this structure type.
        # @scope class
        # @return [VAPI::Bindings::StructType] the binding type
        def binding_type
            @binding_type ||= VAPI::Bindings::StructType.new(
                'com.vmware.cis.tagging.category_model',
                {
                    'id' => VAPI::Bindings::IdType.new(resource_types='com.vmware.cis.tagging.Category'),
                    'name' => VAPI::Bindings::StringType.instance,
                    'description' => VAPI::Bindings::StringType.instance,
                    'cardinality' => VAPI::Bindings::ReferenceType.new('Com::Vmware::Cis::Tagging::CategoryModel::Cardinality'),
                    'associable_types' => VAPI::Bindings::SetType.new(VAPI::Bindings::StringType.instance),
                    'used_by' => VAPI::Bindings::SetType.new(VAPI::Bindings::StringType.instance),
                },
                CategoryModel,
                true,
                ["id"])
        end
    end

    attr_accessor :id,
                  :name,
                  :description,
                  :cardinality,
                  :associable_types,
                  :used_by

    # Constructs a new instance.
    # @param ruby_values [Hash] a map of initial property values (optional)
    # @param struct_value [VAPI::Data::StructValue] a raw StructValue from the wire (optional)
    def initialize(ruby_values=nil, struct_value=nil)
        super(self.class.binding_type, ruby_values, struct_value)
    end


    # The  ``Com::Vmware::Cis::Tagging::CategoryModel::Cardinality``   enumerated type  defines the number of tags in a category that can be assigned to an object.
    # @!attribute [rw] single
    #     @return [Com::Vmware::Cis::Tagging::CategoryModel::Cardinality]
    #     An object can only be assigned one of the tags in this category. For example, if a category is "Operating System", then different tags of this category would be "Windows", "Linux", and so on. In this case a VM object can be assigned only one of these tags and hence the cardinality of the associated category here is single.
    # @!attribute [rw] multiple
    #     @return [Com::Vmware::Cis::Tagging::CategoryModel::Cardinality]
    #     An object can be assigned several of the tags in this category. For example, if a category is "Server", then different tags of this category would be "AppServer", "DatabaseServer" and so on. In this case a VM object can be assigned more than one of the above tags and hence the cardinality of the associated category here is multiple.
    class Cardinality < VAPI::Bindings::VapiEnum

        class << self
            # Holds (gets or creates) the binding type metadata for this enumeration type.
            # @scope class
            # @return [VAPI::Bindings::EnumType] the binding type
            def binding_type
                @binding_type ||= VAPI::Bindings::EnumType.new(
                    'com.vmware.cis.tagging.category_model.cardinality',
                    Cardinality)
            end

            # Converts from a string value (perhaps off the wire) to an instance
            # of this enum type.
            # @param value [String] the actual value of the enum instance
            # @return [Cardinality] the instance found for the value, otherwise
            #         an unknown instance will be built for the value
            def from_string(value)
                begin
                    const_get(value)
                rescue NameError
                    Cardinality.new('UNKNOWN', value)
                end
            end
        end

        private

        # Constructs a new instance.
        # @param value [String] the actual value of the enum instance
        # @param unknown [String] the unknown value when value is 'UKNOWN'
        def initialize(value, unknown=nil)
            super(self.class.binding_type, value, unknown)
        end

        public

        # @!attribute [rw] single
        #     @return [Com::Vmware::Cis::Tagging::CategoryModel::Cardinality]
        #     An object can only be assigned one of the tags in this category. For example, if a category is "Operating System", then different tags of this category would be "Windows", "Linux", and so on. In this case a VM object can be assigned only one of these tags and hence the cardinality of the associated category here is single.
        SINGLE = Cardinality.new('SINGLE')

        # @!attribute [rw] multiple
        #     @return [Com::Vmware::Cis::Tagging::CategoryModel::Cardinality]
        #     An object can be assigned several of the tags in this category. For example, if a category is "Server", then different tags of this category would be "AppServer", "DatabaseServer" and so on. In this case a VM object can be assigned more than one of the above tags and hence the cardinality of the associated category here is multiple.
        MULTIPLE = Cardinality.new('MULTIPLE')

    end


end

Class Method Details

+ (VAPI::Bindings::StructType) binding_type

Holds (gets or creates) the binding type metadata for this structure type.

Returns:

  • (VAPI::Bindings::StructType) —

    the binding type 



1351
1352
1353
1354
1355
1356
1357
1358
1359
1360
1361
1362
1363
1364
1365
 
# File '/build/mts/release/bora-4571906/build/sdk/aggregated-bindings/ruby/com/vmware/cis/tagging.rb', line 1351

def binding_type
    @binding_type ||= VAPI::Bindings::StructType.new(
        'com.vmware.cis.tagging.category_model',
        {
            'id' => VAPI::Bindings::IdType.new(resource_types='com.vmware.cis.tagging.Category'),
            'name' => VAPI::Bindings::StringType.instance,
            'description' => VAPI::Bindings::StringType.instance,
            'cardinality' => VAPI::Bindings::ReferenceType.new('Com::Vmware::Cis::Tagging::CategoryModel::Cardinality'),
            'associable_types' => VAPI::Bindings::SetType.new(VAPI::Bindings::StringType.instance),
            'used_by' => VAPI::Bindings::SetType.new(VAPI::Bindings::StringType.instance),
        },
        CategoryModel,
        true,
        ["id"])
end