Function clearHistVars
        Clear the variables used to get history of all vars

        @return RETURN: None
183475
def clearReqVars(self):
        
        self.errorMsg = None
        self.payload = None
        self.url = None
        self.resp = None
        self.res = None
        self.method = None
        self.printErrors = None
966837
def tidy_all_the_variables(host, inventory_mgr):
    '''  '''
    global _vars
    _vars = dict()
    _vars[host] = inventory_mgr.inventory.get_host_vars(host)
    for group in host.get_groups():
        remove_inherited_and_overridden_vars(_vars[host], group, inventory_mgr)
        remove_inherited_and_overridden_group_vars(group, inventory_mgr)
    return _vars
551165
def ClearVar(self):
    """"""
    self.value = None
    # Call OnClearVar on options.
    _ = [option.OnClearVar() for option in self.options]
999947
def clear(self):
        
        self.__values.clear()
        self.__access_keys = []
        self.__modified_times.clear()
519134
function clear() {
        var that = this;
        var state = getInternalState(that);
        var data = state.index;
        var entry = state.first;
        while (entry) {
          entry.removed = true;
          if (entry.previous) entry.previous = entry.previous.next = undefined;
          delete data[entry.index];
          entry = entry.next;
        }
        state.first = state.last = undefined;
        if (DESCRIPTORS) state.size = 0;
        else that.size = 0;
      }
695706
def reset!
      instance_variables.each { |var| remove_instance_variable var }
      constants.each do |c|
        c = const_get(c)
        c.reset! if c.respond_to?(:reset!)
      end
    end
74731
def clear(self) -> None:
        
        r = self.__api.delete('containers')
        if r.status_code != 204:
            self.__api.handle_erroneous_response(r)
952028
def clear(self):
        
        dict.clear(self)
        self.scalars = []
        self.sections = []
        self.comments = {}
        self.inline_comments = {}
        self.configspec = None
        self.defaults = []
        self.extra_values = []
393581
def clear(self):
        
        codec.Context.clear(self)

        self.strings.clear()
        self.proxied_objects = {}
        self.classes = {}
        self.class_ref = {}

        self.class_idx = 0
580963
def remove(self, variables: Union[Iterable[str], Dict[str, str]]=None):
        
        keys = list(variables.keys()) if isinstance(variables, Dict) else variables     # type: Iterable[str]
        for key in keys:
            variable = self._project.variables.get(key)
            if isinstance(variables, Dict):
                if variables[key] != variable.value:
                    continue
            variable.delete()
512380
def _clear(self):
        
        self.__names.clear()
        self.__queue.clear()
        self.__context = None
693612
def clear(self):
        
        with self._hlock:
            self.handlers.clear()
        with self._mlock:
            self.memoize.clear()
537837
def clear(self):
        
        with self.__bnd_lock:
            self.__bnd_listeners = []

        with self.__svc_lock:
            self.__svc_listeners.clear()

        with self.__fw_lock:
            self.__fw_listeners = []
584337
def clear!(*args)
      internal_lock do
        args = registry.keys if args.empty?
        args.each do |key|
          value = self[key]
          if value.respond_to?(:clear)
            value.clear
          elsif value.respond_to?(:value)
            value.value = nil
          end
          registry.delete(key)
        end
        yield if block_given?
      end
      true
    end
1274546
public function clear()
    {
        $shmid = shm_attach($this->sysvKey, $this->shmSize, $this->perm);
        shm_remove_var($shmid, self::VAR_KEY);
    }
949935
def clear(self):
        
        # The del_binfo() call here isn't necessary for normal execution,
        # but is for interactive mode, where we might rebuild the same
        # target and need to start from scratch.
        self.del_binfo()
        self.clear_memoized_values()
        self.ninfo = self.new_ninfo()
        self.executor_cleanup()
        try:
            delattr(self, '_calculated_sig')
        except AttributeError:
            pass
        self.includes = None
317002
def remove_all_lvs(self):
        
        lvs = self.lvscan()
        for lv in lvs:
            self.remove_lv(lv)