Set name for SDS
        :param name: Name of SDS
        :param sdsObj: ScaleIO SDS object
        :return: POST request response
        :rtype: Requests POST response object
492982
def set_sds_name(self, name, sdsObj):
        
        # TODO:
        # Check if object parameters are the correct type, otherwise throw error
        # UNSURE IF THIS IS CORRECT WAY TO SET SDS NAME
        self.conn.connection._check_login()
        sdsNameDict = {'sdsName': name}
        response = self.conn.connection._do_post("{}/{}{}/{}".format(self.conn.connection._api_url, "instances/Sds::", sdcObj.id, 'action/setSdsName'), json=sdsNameDict)    
        return response
1182550
def set_display_name(self, display_name):
        
        self.displayname = display_name
        return self.api.set_display_name(self.user_id, display_name)
1068623
def name(self, name):
        
        success = idaapi.set_enum_member_name(self.cid, name)
        if not success:
            raise exceptions.CantRenameEnumMember(
                "Failed renaming {!r} to {!r}. Does the name exist somewhere else?".format(self.name, name))
264007
public void setName(String name) {

        m_name = name;
        if (LOG.isDebugEnabled()) {
            LOG.debug(Messages.get().getBundle().key(Messages.LOG_SET_NAME_1, name));
        }
    }
284121
public void setName(String name) {
		if (name == null) {
			throw new IllegalArgumentException("Field name cannot be null");
		}

		if (name.length() == 0 || name.length() > 10) {
			throw new IllegalArgumentException("Field name should be of length 0-10");
		}
		if (!DBFUtils.isPureAscii(name)) {
			throw new IllegalArgumentException("Field name must be ASCII");
		}
		this.name = name;
	}
600759
def request_service(name)
      # Use RequestName, but asynchronously!
      # A synchronous call would not work with service activation, where
      # method calls to be serviced arrive before the reply for RequestName
      # (Ticket#29).
      proxy.RequestName(name, NAME_FLAG_REPLACE_EXISTING) do |rmsg, r|
        # check and report errors first
        raise rmsg if rmsg.is_a?(Error)
        raise NameRequestError unless r == REQUEST_NAME_REPLY_PRIMARY_OWNER
      end
      @service = Service.new(name, self)
      @service
    end
1350440
protected void setNamespaceID(Properties props, StorageDirectory sd)
      throws InconsistentFSStateException {
    int nsId = Integer.parseInt(getProperty(props, sd, NAMESPACE_ID));
    if (namespaceID != 0 && nsId != 0 && namespaceID != nsId) {
      throw new InconsistentFSStateException(sd.root,
          "namespaceID is incompatible with others.");
    }
    namespaceID = nsId;
  }
739051
def set_faultset_name(self, name, fsObj):
        
        # Set name of FaultSet
        self.conn.connection._check_login()
        faultSetNameDict = {'Name': name}
        # This one is the most logical name comparing to other methods.
        response = self.conn.connection._do_post("{}/{}{}/{}".format(self.conn.connection._api_url, "types/FaultSet::", fsObj.id, 'instances/action/setFaultSetName'), json=faultSetNameSdcDict)    

        # This is how its documented in REST API Chapter
        #response = self._do_post("{}/{}{}/{}".format(self._api_url, "types/FaultSet::", fsObj.id, 'instances/action/setFaultSetName'), json=faultsetNameSdcDict)    
        return response
430118
public void setPublishedName(String name) {
        //log.debug("setPublishedName: {}", name);
        // a publish name of "false" is a special case, used when stopping a stream
        if (StringUtils.isNotEmpty(name) && !"false".equals(name)) {
            this.publishedName = name;
            registerJMX();
        }
    }
3313
def name(self, name: str):
        

        self.pathName = os.path.join(self.path, name)
724303
def set_name(self, name, kind_attr=None):
        
        self.name = name
        self.kind_attr = kind_attr or "{name}_kind".format(name=name)
        if self.cname is None:
            self.cname = name

        return self
682084
def get_sdb_id(self, sdb):
        
        json_resp = self.get_sdbs()
        for r in json_resp:
            if r['name'] == sdb:
                return str(r['id'])

        # If we haven't returned yet then we didn't find what we were
        # looking for.
        raise CerberusClientException("'%s' not found" % sdb)
201865
def set_name(self, name="My Colormap"):
        
        if not type(name)==str:
            print("set_name(): Name must be a string.")
            return
        self._name = name
        return self
1012284
def __set_name(self, value):
        '''
        
        '''
        if not value or not len(value):
            raise ValueError("Invalid name.")

        self.__name = value
163621
def name(self, name):
        
        weight, width, custom_name = self._splitName(name)
        self.set_all_name_components(name, weight, width, custom_name)
54950
def request_name(self, bus_name, flags) :
        ""
        if not self._registered_bus_names_listeners :
            self.connection.bus_add_match_action \
              (
                rule = "type=signal,interface=org.freedesktop.DBus,member=NameAcquired",
                func = self._bus_name_acquired,
                user_data = self
              )
            self.connection.bus_add_match_action \
              (
                rule = "type=signal,interface=org.freedesktop.DBus,member=NameLost",
                func = self._bus_name_lost,
                user_data = self
              )
            self._registered_bus_names_listeners = True
        #end if
        return \
            self.connection.bus_request_name(bus_name, flags)
819234
def set_name(self, new_name):
        

        yield from self._hypervisor.send('nio_bridge rename "{name}" "{new_name}"'.format(name=self._name,
                                                                                          new_name=new_name))

        self._name = new_name