Clears the assessments.

        raise:  NoAccess - ``Metadata.isRequired()`` or
                ``Metadata.isReadOnly()`` is ``true``
        *compliance: mandatory -- This method must be implemented.*
421939
def clear_assessments(self):
        
        # Implemented from template for osid.learning.ActivityForm.clear_assets_template
        if (self.get_assessments_metadata().is_read_only() or
                self.get_assessments_metadata().is_required()):
            raise errors.NoAccess()
        self._my_map['assessmentIds'] = self._assessments_default
1105659
public function clear()
    {
        $this->id = null;
        $this->key = null;
        $this->value = null;
        $this->alreadyInSave = false;
        $this->alreadyInValidation = false;
        $this->alreadyInClearAllReferencesDeep = false;
        $this->clearAllReferences();
        $this->resetModified();
        $this->setNew(true);
        $this->setDeleted(false);
    }
450061
def clear(self, clear_indices=False):
        ''
        super(MIMapping, self).clear()
        if clear_indices:
            self.indices.clear()
        else:
            for index_d in self.indices[1:]:
                index_d.clear()
937110
def clear_cycles(self):
        """"""
        if self.rater is None:
            raise IndexError('You need to have at least one rater')

        cycles = self.rater.find('cycles')
        for cyc in list(cycles):
            cycles.remove(cyc)

        self.save()
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
100858
def clear_branding(self):
        
        if (self.get_branding_metadata().is_read_only() or
                self.get_branding_metadata().is_required()):
            raise NoAccess()
        self.my_osid_object_form._my_map['brandingIds'] = self._branding_default
924237
def clear_taker(self):
        
        # Implemented from template for osid.resource.ResourceForm.clear_avatar_template
        if (self.get_taker_metadata().is_read_only() or
                self.get_taker_metadata().is_required()):
            raise errors.NoAccess()
        self._my_map['takerId'] = self._taker_default
869693
public void clear() {
        Optional.ofNullable(phantomReference).ifPresent(ref -> pool.getLeakDetector().clear(ref));
    }
1351164
def _clear(self):
        """"""
        self._finished = False
        self._measurement = None
        self._message = None
        self._message_body = None
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]
1202012
def clear(self):
        
        self._lock = None
        self._ipopo_instance = None
        self._context = None
        self.requirement = None
        self._value = None
        self._field = None
1162295
def clear_score(self):
        
        if self._grade_system.is_based_on_grades():
            return  # do nothing, spec does not raise error
        if (self.get_score_metadata().is_read_only() or
                self.get_score_metadata().is_required()):
            raise errors.NoAccess()
        self._my_map['score'] = self._score_default
        self._my_map['gradingAgentId'] = ''
        self._my_map['timeGraded'] = None
340700
def clear_text(self):
        
        # Implemented from template for osid.repository.AssetForm.clear_title_template
        if (self.get_text_metadata().is_read_only() or
                self.get_text_metadata().is_required()):
            raise errors.NoAccess()
        self._my_map['text'] = dict(self._text_default)
353542
def clear(self):
        

        if self._formats:
            for fmt in self._formats:
                fmt.clear()
        self._formats = None
1231369
public function clear()
    {
        $this->id = null;
        $this->code = null;
        $this->en = null;
        $this->de = null;
        $this->alreadyInSave = false;
        $this->alreadyInValidation = false;
        $this->alreadyInClearAllReferencesDeep = false;
        $this->clearAllReferences();
        $this->applyDefaultValues();
        $this->resetModified();
        $this->setNew(true);
        $this->setDeleted(false);
    }
1086190
public function clear()
    {
        $this->id = null;
        $this->name = null;
        $this->role = null;
        $this->alreadyInSave = false;
        $this->alreadyInValidation = false;
        $this->alreadyInClearAllReferencesDeep = false;
        $this->clearAllReferences();
        $this->resetModified();
        $this->setNew(true);
        $this->setDeleted(false);
    }
286997
def clear(self):
        
        # mark this task as incomplete
        self.mark_incomplete()

        # Delete the indicator metadata, this also deletes values by cascading.
        #
        # NOTE: calling 'delete()' on the query (instead of on the queried object,
        # as done here), would NOT work! For a query, there is no in-Python cascading
        # of delete statements in sqlalchemy, so the associated values would not
        # be deleted e.g. for SQLite databases.
        try:
            indicator = self.session.query(models.EuroStatIndicator) \
                .filter(models.EuroStatIndicator.number == self.number) \
                .one()
            self.session.delete(indicator)
        except NoResultFound:
            # Data didn't exist yet, no problem
            pass

        self.close_session()