Sets the adapter type for this VMware VM instance.

        :param adapter_type: adapter type (string)
12225
def adapter_type(self, adapter_type):
        

        self._adapter_type = adapter_type
        log.info("VMware VM '{name}' [{id}]: adapter type changed to {adapter_type}".format(name=self.name,
                                                                                            id=self.id,
                                                                                            adapter_type=adapter_type))
9162
def _get_hba_type(hba_type):
    '''
    
    '''
    if hba_type == "parallel":
        return vim.host.ParallelScsiHba
    elif hba_type == "block":
        return vim.host.BlockHba
    elif hba_type == "iscsi":
        return vim.host.InternetScsiHba
    elif hba_type == "fibre":
        return vim.host.FibreChannelHba

    raise ValueError('Unknown Host Bus Adapter Type')
1182197
def _set_rpc(self, rpc_type: str) -> None:
        
        if rpc_type == "infura":
            self.set_api_rpc_infura()
        elif rpc_type == "localhost":
            self.set_api_rpc_localhost()
        else:
            self.set_api_rpc(rpc_type)
667808
def setType(self, vehID, typeID):
        
        self._connection._sendStringCmd(
            tc.CMD_SET_VEHICLE_VARIABLE, tc.VAR_TYPE, vehID, typeID)
947030
public void setCostType(com.google.api.ads.admanager.axis.v201902.CostType costType) {
        this.costType = costType;
    }
475401
def network_type=(type)
      no_cmd = (type == default_network_type) ? 'no' : ''
      network = (type == default_network_type) ? '' : type
      network = 'point-to-point' if type.to_s == 'p2p'
      config_set('interface_ospf', 'network_type', @interface.name,
                 no_cmd, network)
    end
279154
def _set_bucket(self, type, name):
        
        if type:
            self._cfg['bucket_type'] = type
        if name:
            self._cfg['bucket_name'] = name
        self.bucket = self._client.bucket_type(self._cfg['bucket_type']
                                               ).bucket(self._cfg['bucket_name'])
        self.index_name = "%s_%s" % (self._cfg['bucket_type'], self._cfg['bucket_name'])
        return self
794438
def is_config_type(type_):
    

    return (
        isinstance(type_, type)
        and hasattr(type_, "__attrs_attrs__")
        and hasattr(type_, CONFIG_KEY)
    )
343606
public void setAce_type(String v) {
    if (SourceFile_Type.featOkTst && ((SourceFile_Type)jcasType).casFeat_ace_type == null)
      jcasType.jcas.throwFeatMissing("ace_type", "de.julielab.jules.types.ace.SourceFile");
    jcasType.ll_cas.ll_setStringValue(addr, ((SourceFile_Type)jcasType).casFeatCode_ace_type, v);}
105171
public function setAdapter($adapter)
    {
        if (\is_callable($adapter)) {
            $adapter = \call_user_func($adapter, $this->container);
        }

        $this->adapter = $adapter;
    }
762096
public static void setDefaultVCConnectionType(VirtualConnection vc) {
        if (vc == null) {
            return;
        }

        Map<Object, Object> map = vc.getStateMap();

        // Pick defaults for INBOUND/OUTBOUND
        // setVCConnectionType will only set these values in the VC if
        // a type has not been preset.
        if (map.get(CONNECTION_TYPE_VC_KEY) == null) {
            if (vc instanceof InboundVirtualConnection) {
                map.put(CONNECTION_TYPE_VC_KEY, ConnectionType.INBOUND);
            } else {
                map.put(CONNECTION_TYPE_VC_KEY, ConnectionType.OUTBOUND);
            }
        }
    }
829881
def inherit_type(self, type_cls: Type[TInherit]) \
            -> Union[TInherit, 'Publisher']:
        
        self._inherited_type = type_cls
        return self
899777
def register_adapter(from_classes, to_classes, func):
    
    assert from_classes, 'Must supply classes to adapt from'
    assert to_classes, 'Must supply classes to adapt to'
    assert func, 'Must supply adapter function'

    if not isinstance(from_classes, (tuple, list)):
        from_classes = [from_classes]
    if not isinstance(to_classes, (tuple, list)):
        to_classes = [to_classes]

    for key in itertools.product(from_classes, to_classes):
        if key in __adapters__:
            raise AdapterExists('%r to %r already exists.' % key)
        __adapters__[key] = func
1367781
public void setLedType(final LedType LED_TYPE) {
        if (ledType == LED_TYPE) {return;}

        ledType = LED_TYPE;
        final boolean LED_WAS_ON = currentLedImage.equals(ledImageOn) ? true : false;
        flushImages();
        ledImageOff = create_LED_Image(getWidth(), 0, ledColor, ledType);
        ledImageOn = create_LED_Image(getWidth(), 1, ledColor, ledType);

        currentLedImage = LED_WAS_ON == true ? ledImageOn : ledImageOff;

        repaint();
    }
716047
function loadAdapter(type, location) {
    var options = adapterConfig[type];
    try {
        var modulePath = adapterModulePath(type, options);

        global.JuttleAdapterAPI = JuttleAdapterAPI;

        var start = new Date();

        if (!options.builtin) {
            checkCompatible(type, modulePath, location);
        }

        var init = require(modulePath);

        var loaded = new Date();
        var adapter = init(options);

        global.JuttleAdapterAPI = undefined;

        if (adapter.name !== type) {
            throw new Error('adapter name ', adapter.name, ' != type ', type);
        }
        var initialized = new Date();

        logger.debug(adapter.name, 'adapter loaded in', (loaded - start), 'ms,',
                     'initialized in', (initialized - loaded), 'ms');

        register(adapter.name, adapter);

        return adapter;
    } catch (err) {
        logger.error('error loading adapter ' + type + ': ' + err.message);
        throw err;
    }
}
61740
public function setAdapterType($type)
    {
        $adapter_type = '\Library\Reporter\Adapter\\'.ucfirst($type);
        if (class_exists($adapter_type)) {
            $this->setAdapter(new $adapter_type);
        } else {
            throw new \RuntimeException(
                sprintf('Reporter adapter for type "%s" doesn\'t exist!', $adapter_type)
            );
        }
        return $this;
    }
298930
def get_network_adapter_object_type(adapter_object):
    '''
    
    '''
    if isinstance(adapter_object, vim.vm.device.VirtualVmxnet2):
        return 'vmxnet2'
    if isinstance(adapter_object, vim.vm.device.VirtualVmxnet3):
        return 'vmxnet3'
    if isinstance(adapter_object, vim.vm.device.VirtualVmxnet):
        return 'vmxnet'
    if isinstance(adapter_object, vim.vm.device.VirtualE1000e):
        return 'e1000e'
    if isinstance(adapter_object, vim.vm.device.VirtualE1000):
        return 'e1000'

    raise ValueError('An unknown network adapter object type.')