Clears the rubric.

        raise:  NoAccess - ``Metadata.isRequired()`` or
                ``Metadata.isReadOnly()`` is ``true``
        *compliance: mandatory -- This method must be implemented.*
15585
def clear_rubric(self):
        
        # Implemented from template for osid.resource.ResourceForm.clear_avatar_template
        if (self.get_rubric_metadata().is_read_only() or
                self.get_rubric_metadata().is_required()):
            raise errors.NoAccess()
        self._my_map['rubricId'] = self._rubric_default
1174957
def clear_composition(self):
        
        # Implemented from template for osid.resource.ResourceForm.clear_avatar_template
        if (self.get_composition_metadata().is_read_only() or
                self.get_composition_metadata().is_required()):
            raise errors.NoAccess()
        self._my_map['compositionId'] = self._composition_default
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
1096115
def clear(self):
        
        self.reference = None
        self._pending_ref = None
        super(SimpleDependency, self).clear()
122010
def clear_elements(sysmeta_pyxb, clear_replica=True, clear_serial_version=True):
    
    if clear_replica:
        sysmeta_pyxb.replica = None
    if clear_serial_version:
        sysmeta_pyxb.serialVersion = None

    sysmeta_pyxb.replicationPolicy = None
1249860
@Override
    public void clear() {
        readOnlyGuardCondition();

        for (D item : this) {
            instance.removeRelation(entity, writeAttributeName, item);
        }
        entity.save();
    }
583683
public void clear() {
        if (mCardNumberEditText.hasFocus()
                || mExpiryDateEditText.hasFocus()
                || mCvcNumberEditText.hasFocus()
                || this.hasFocus()) {
            mCardNumberEditText.requestFocus();
        }
        mCvcNumberEditText.setText("");
        mExpiryDateEditText.setText("");
        mCardNumberEditText.setText("");
    }
321695
def isReadOnly( self ):
        
        if ( self._editor and hasattr(self._editor, 'isReadOnly') ):
            return self._editor.isReadOnly()
        return False
737851
private void clearEdit() {

        m_fileTable.setEditable(false);
        if (m_editItemId != null) {
            updateItem(m_editItemId, false);
        }
        m_editItemId = null;
        m_editProperty = null;
        m_editHandler = null;
        updateSorting();
    }
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]
1341807
def clear_bp(cls, ctx, register):
        
        ctx['Dr7'] &= cls.clearMask[register]
        ctx['Dr%d' % register] = 0
196078
def clear_display_name(self):
        
        if (self.get_display_name_metadata().is_read_only() or
                self.get_display_name_metadata().is_required()):
            raise errors.NoAccess()
        self._my_map['displayName'] = dict(self._display_name_default)
1242299
def clear_published_date(self):
        
        # Implemented from template for osid.assessment.AssessmentOfferedForm.clear_start_time_template
        if (self.get_published_date_metadata().is_read_only() or
                self.get_published_date_metadata().is_required()):
            raise errors.NoAccess()
        self._my_map['publishedDate'] = self._published_date_default
278269
public void clear(){
		this.errors.clearErrorMessages();;

		this.warnings.clear();
		this.infos.clear();

		this.scDir = 0;
		this.scDirUnreadable = 0;
		this.scFiles = 0;
		this.scFilesUnreadable = 0;
	}
44429
private boolean removeUnreadable() {
		List<File> unreadable = inventory.removeUnreadable();
		unreadable.forEach(v->v.delete());
		return !unreadable.isEmpty();
	}
277619
def cleared=(cleared)
      validator = EnumAttributeValidator.new('String', ['cleared', 'uncleared', 'reconciled'])
      unless validator.valid?(cleared)
        fail ArgumentError, 'invalid value for "cleared", must be one of #{validator.allowable_values}.'
      end
      @cleared = cleared
    end
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