Clears the level.

        raise:  NoAccess - ``Metadata.isRequired()`` or
                ``Metadata.isReadOnly()`` is ``true``
        *compliance: mandatory -- This method must be implemented.*
358503
def clear_level(self):
        
        if (self.get_level_metadata().is_read_only() or
                self.get_level_metadata().is_required()):
            raise errors.NoAccess()
        self._my_map['levelId'] = self._level_default
        self._my_map['level'] = self._level_default
1136284
def clear_duration(self):
        
        # Implemented from template for osid.assessment.AssessmentOfferedForm.clear_duration_template
        if (self.get_duration_metadata().is_read_only() or
                self.get_duration_metadata().is_required()):
            raise errors.NoAccess()
        self._my_map['duration'] = self._duration_default
1163855
def zeroize_after_level(self, base_level):
        
        index = _LEVELS.index(base_level) + 1
        for level in _LEVELS[index:]:
            self.version_info[level] = 0
1268065
def clear_description(self):
        
        if (self.get_domain_metadata().is_read_only() or
                self.get_domain_metadata().is_required()):
            raise errors.NoAccess()
        self._my_map['domain'] = self._domain_metadata['default_string_values'][0]
1351164
def _clear(self):
        """"""
        self._finished = False
        self._measurement = None
        self._message = None
        self._message_body = None
498258
def clear(self):
    """"""
    for i in range(len(self.sample)):
      self.sample[i] = 0.0
    self.count = 0
583683
public void clear() {
        if (mCardNumberEditText.hasFocus()
                || mExpiryDateEditText.hasFocus()
                || mCvcNumberEditText.hasFocus()
                || this.hasFocus()) {
            mCardNumberEditText.requestFocus();
        }
        mCvcNumberEditText.setText("");
        mExpiryDateEditText.setText("");
        mCardNumberEditText.setText("");
    }
1374692
def clear(self, flush=True):
        

        if self.enabled:
            self.manager.write(flush=flush, position=self.position)
934572
def clear_allocated_time(self):
        
        # Implemented from template for osid.assessment.AssessmentOfferedForm.clear_duration_template
        if (self.get_allocated_time_metadata().is_read_only() or
                self.get_allocated_time_metadata().is_required()):
            raise errors.NoAccess()
        self._my_map['allocatedTime'] = self._allocated_time_default
272490
def clear(self):
        
        # mark this task as incomplete
        self.mark_incomplete()

        # Delete the indicator metadata, this also deletes values by cascading.
        for suffix in list(CLIMATE_SEASON_SUFFIXES.values()):
            try:
                # noinspection PyUnresolvedReferences
                indicator = self.session.query(models.ClimateIndicator) \
                    .filter(models.ClimateIndicator.description == self.description + suffix) \
                    .one()
                self.session.delete(indicator)
            except NoResultFound:
                # Data didn't exist yet, no problem
                pass

        self.close_session()
1318093
def clear(self):
		

		header = bytearray()
		header.append(LightProtocolCommand.Clear)

		return self.send(header)
829509
def clear(self):
        """"""
        for i in range(self.maxlevel):
            self._head[2+i] = self._tail
            self._tail[-1] = 0
        self._level = 1
947610
def clear(self):
		'''
		
		'''
		for node in self.dli():
			node.empty = True
			node.key = None
			node.value = None
		
		self.head = _dlnode()
		self.head.next = self.head
		self.head.prev = self.head
		self.listSize = 1
		
		self.table.clear()
		
		# status var
		self.hit_cnt = 0 
		self.miss_cnt = 0
		self.remove_cnt = 0
764990
def clear_items_sequential(self):
        
        # Implemented from template for osid.resource.ResourceForm.clear_group_template
        if (self.get_items_sequential_metadata().is_read_only() or
                self.get_items_sequential_metadata().is_required()):
            raise errors.NoAccess()
        self._my_map['itemsSequential'] = self._items_sequential_default
950895
def clear(self, key=None):
        
        if not self.options.enabled:
            return CACHE_DISABLED
        logger.debug('clear(key={})'.format(repr(key)))
        if key is not None and key in self._dict.keys():
            del self._dict[key]
            logger.info('cache cleared for key: ' + repr(key))
        elif not key:
            for cached_key in [k for k in self._dict.keys()]:
                del self._dict[cached_key]
            logger.info('cache cleared for ALL keys')
        return True
780003
def clear(self):
        """"""
        self._clear()
        if self._current_metadata != self._default_metadata:
            self._current_metadata = _get_metadata_for_region(self._default_country)
665037
def clear_output_score(self):
        
        # Implemented from template for osid.grading.GradeSystemForm.clear_lowest_numeric_score
        if (self.get_output_score_metadata().is_read_only() or
                self.get_output_score_metadata().is_required()):
            raise errors.NoAccess()
        self._my_map['outputScore'] = self._output_score_default