Rename the root timer (regardless of current timing level).

    Args:
        name (any): Identifier, passed through str()

    Returns:
        str: Implemented identifier.
761084
def rename_root(name):
    
    name = str(name)
    f.root.name = name
    f.root.times.name = name
    return name
1030036
def renamecol(self, oldname, newname):
        
        self._renamecol(oldname, newname)
        self._makerow()
3313
def name(self, name: str):
        

        self.pathName = os.path.join(self.path, name)
1287371
def set_name(self,name=None):
        
        if name:
            self.name = name[:254]
        else:
            self.name = self.extract_name()[:254]

        self.save()

        return self.name
280080
def set_name(self, name):
        
        self.name = name
        self.changed_event.emit(self)
24810
public void logRename(String src, String dst, long timestamp) {
    RenameOp op = RenameOp.getInstance();
    op.set(src, dst, timestamp);
    logEdit(op);
  }
461019
def rename(name, new_name):
    '''
    
    '''
    current_info = info(name)
    if not current_info:
        raise CommandExecutionError('User \'{0}\' does not exist'.format(name))
    new_info = info(new_name)
    if new_info:
        raise CommandExecutionError(
            'User \'{0}\' already exists'.format(new_name)
        )
    _dscl(
        ['/Users/{0}'.format(name), 'RecordName', name, new_name],
        ctype='change'
    )
    # dscl buffers changes, sleep 1 second before checking if new value
    # matches desired value
    time.sleep(1)
    return info(new_name).get('RecordName') == new_name
1044717
def name(self, name):
        
        if name is None:
            raise ValueError("Invalid value for `name`, must not be `None`")
        if name is not None and len(name) > 200:
            raise ValueError("Invalid value for `name`, length must be less than or equal to `200`")

        self._name = name
1292256
def rename(self, new_name):
    
    update = copy.copy(self)
    update.name = new_name
    return self._do_update(update)
1222394
def _set_name(self, name, inplace=False):
        
        inplace = validate_bool_kwarg(inplace, 'inplace')
        ser = self if inplace else self.copy()
        ser.name = name
        return ser
938071
def __normalize_name(self, name):
        

        if not name.startswith(self.__root_namespace):
            name = foundations.namespace.set_namespace(self.__root_namespace,
                                                       foundations.namespace.set_namespace(self.__default_namespace,
                                                                                           name))
            LOGGER.debug("> Normalized name: '{0}'.".format(name))
            return name
        else:
            LOGGER.debug("> Name '{0}' is already normalized!".format(name))
            return name
1007952
def _rename(self):
        
        newname = self.action['newname']
        try:
            newpath = self.fs.rename(self.fp,newname)
        except OSError:
            raise tornado.web.HTTPError(400)
        return newpath
548564
def rename(args):
    """"""
    old_name, new_name = args.names
    add_tags(resources.ec2.Instance(resolve_instance_id(old_name)), Name=new_name, dry_run=args.dry_run)
202739
public void setOriginalAppenderName(String name) {
        this.originalAppenderName = name;
        this.initBatcher(this.originalAppenderName);
        this.putBufferTimeTracer = Monitors.newTimer("putBuffer",
                TimeUnit.NANOSECONDS);
        this.putDiscardMapTimeTracer = Monitors.newTimer("putDiscardMap",
                TimeUnit.NANOSECONDS);
        this.locationInfoTimer = Monitors.newTimer("locationInfo",
                TimeUnit.NANOSECONDS);
        this.saveThreadLocalTimer = Monitors.newTimer("saveThreadLocal",
                TimeUnit.NANOSECONDS);

        // We register these counters differently to the above timers, because need to keep the metric names as they were when we were
        // using DynamicCounter.increment() directly.
        this.summarizeEventCounter = initAndRegisterCounter(this.originalAppenderName + "_summarizeEvent");
        this.discardEventCounter = initAndRegisterCounter(this.originalAppenderName + "_discardEvent");
        this.putInBufferCounter = initAndRegisterCounter(this.originalAppenderName + "_putInBuffer");

        this.logSummaryMap = CacheBuilder
                .newBuilder()
                .initialCapacity(5000)
                .maximumSize(
                        CONFIGURATION.getLogSummarySize(originalAppenderName))
                .expireAfterWrite(
                        CONFIGURATION
                                .getLogSummaryExpiry(originalAppenderName),
                        TimeUnit.SECONDS).<String, LogSummary> build().asMap();
        try {
            Monitors.registerObject(this.originalAppenderName, this);
        } catch (Throwable e) {
            if (CONFIGURATION.shouldPrintLoggingErrors()) {
                System.err.println("Cannot register monitor for AsyncAppender "
                        + this.originalAppenderName);
                e.printStackTrace();
            }
        }
    }
1088863
def rename(self, name):
        
        if name is None:
            raise Exception("name (%s) not-valid" % (name,))
        self.prefix, self.name = splitPrefix(name)
351725
def addrs_for_name(self, n):
        
        if n not in self._name_mapping:
            return

        self._mark_updated_mapping(self._name_mapping, n)

        to_discard = set()
        for e in self._name_mapping[n]:
            try:
                if n in self[e].object.variables: yield e
                else: to_discard.add(e)
            except KeyError:
                to_discard.add(e)
        self._name_mapping[n] -= to_discard
285543
def get(cls, name):
        
        if name in cls.timer_end:
            cls.timer_elapsed[name] = cls.timer_end[name] - \
                                      cls.timer_start[name]
            return cls.timer_elapsed[name]
        else:
            return "undefined"