Cleans the values in each cell. Calls either the user provided clean_value, or the
    class defined clean value.
342232
def clean_values(self):
    
    for row in self.rows:
      for index, cell in enumerate(row):
        self.set_cell_value(row, index, self.clean_value(self.get_cell_value(cell)))
    return self
529034
public void clear() {
	column = new String[0];
	types = null;
	rows = new Vector();
	ncolumns = nrows = 0;
	atmaxrows = false;
    }
1105463
def clean(self, data):
        
        try:
            value = data[self.column_name]
        except KeyError:
            raise KeyError("Column '%s' not found in dataset. Available "
                           "columns are: %s" % (self.column_name, list(data)))

        # If ValueError is raised here, import_obj() will handle it
        value = self.widget.clean(value, row=data)

        if value in self.empty_values and self.default != NOT_PROVIDED:
            if callable(self.default):
                return self.default()
            return self.default

        return value
540825
public function clearValues()
    {
        foreach ($this->record as $key => $value) {
            $this->record[$key] = null;
        }
    }
398643
def clean(self, value):
        """"""

        if isinstance(value, six.string_types):
            return value
        elif isinstance(value, numbers.Number):
            return str(value)

        raise ParameterNotValidError
140231
public void clear() {
        for (int i = cells.size() - 1; i >= 0; i--) {
            Cell<C, T> cell = cells.get(i);
            if (cell.widget != null)
                toolkit.removeChild(table, cell.widget);
            toolkit.freeCell(cell);
        }
        cells.clear();
        rows = 0;
        columns = 0;
        if (rowDefaults != null)
            toolkit.freeCell(rowDefaults);
        rowDefaults = null;
        invalidate();
    }
200237
def clean(self, data):
        """"""
        cleaned_data = list()

        if not isinstance(data, list):
            data = [data]

        for item in data:
            date = datetime.datetime.strptime(item['Date'], '%Y-%m-%d').date()
            cleaned_data.append(dict(price=item['Adj_Close'], date=date))

        return cleaned_data
1338947
public void clear() {
        int h = head;
        int t = tail;
        if (h != t) { // clear all cells
            head = tail = 0;
            int i = h;
            int mask = elements.length - 1;
            do {
                elements[i] = null;
                i = (i + 1) & mask;
            } while (i != t);
        }
    }
685238
def clean_for_doc(nb):
    
    new_cells = []
    for cell in nb.worksheets[0].cells:
        # Remove the pylab inline line.
        if "input" in cell and cell["input"].strip() == "%pylab inline":
            continue
        # Remove output resulting from the stream/trace method chaining.
        if "outputs" in cell:
            outputs = [_i for _i in cell["outputs"] if "text" not in _i or
                       not _i["text"].startswith("<obspy.core")]
            cell["outputs"] = outputs
        new_cells.append(cell)
    nb.worksheets[0].cells = new_cells
    return nb
885415
def _clean_dirty(self, obj=None):
        
        obj = obj or self
        obj.__dict__['_dirty_attributes'].clear()
        obj._dirty = False
        for key, val in vars(obj).items():
            if isinstance(val, BaseObject):
                self._clean_dirty(val)
            else:
                func = getattr(val, '_clean_dirty', None)
                if callable(func):
                    func()
1151265
private void _cleanChildren() {
        //bStatsTreeNeedsUpdate = true;
        if (children != null) {
            Iterator values = children.values().iterator();

            while (values.hasNext()) {
                ModuleItem remMI = (ModuleItem) values.next();
                remMI.getInstance().cleanup();

                //_cleanMBean(remMI);
                remMI._cleanChildren();
                remMI = null;
            }

            children.clear();
        }
    }
457043
protected void cleanRow() {
        int i = 0;
        while(i < this.cells.size()) {
            if(((RtfCell) this.cells.get(i)).isDeleted()) {
                this.cells.remove(i);
            } else {
                i++;
            }
        }
    }
962068
def clean(self, value):
        
        if not value:
            raise ValidationError(
                'Error found in Form Field: Nothing to validate')

        data = dict((bf.name, value[i]) for i, bf in enumerate(self.form))
        self.form = form = self.form.__class__(data)
        if not form.is_valid():
            error_dict = list(form.errors.items())
            raise ValidationError([
                ValidationError(mark_safe('{} {}'.format(
                    k.title(), v)), code=k) for k, v in error_dict])

        # This call will ensure compress is called as expected.
        return super(FormField, self).clean(value)
626360
def scrub(value, scrub_text=_keep_whitespace, scrub_number=_scrub_number):
    
    return _scrub(value, set(), [], scrub_text=scrub_text, scrub_number=scrub_number)
783171
public static void cleanup ()
  {
    if (MimeTypeInfoManager.isDefaultInstantiated ())
      MimeTypeInfoManager.getDefaultInstance ().reinitializeToDefault ();
    if (MicroTypeConverterRegistry.isInstantiated ())
      MicroTypeConverterRegistry.getInstance ().reinitialize ();
    if (XMLSchemaCache.isInstantiated ())
      XMLSchemaCache.getInstance ().clearCache ();
    XMLSchemaCache.clearPerClassLoaderCache ();
  }
483174
def _clean(self, value):
		""""""
		
		value = (str(v) for v in value)
		
		if self.strip:
			value = (v.strip() for v in value)
		
		if not self.empty:
			value = (v for v in value if v)
		
		return value
1316320
def clean(self, value):
		

		# If the value is None and it's optional, return as is
		if value is None and self._optional:
			return None

		# Go through each of the nodes
		for i in range(len(self._nodes)):

			# If it's valid
			if self._nodes[i].valid(value):

				# Use it's clean
				return self._nodes[i].clean(value)

		# Something went wrong
		raise ValueError('value', value)