Clears all the internal Records of the Dataframe. The Dataframe can be used
after you clear it.
329018
@Override
    public void clear() {
        data.yDataType = null;
        data.atomicNextAvailableRecordId.set(0);
        data.xDataTypes.clear();
        data.records.clear();
    }
970479
public void removeAll()
    {
        if (m_aRecords != null)
        {
            for (int iArrayIndex = 0; iArrayIndex < MAX_RECORD_ARRAY_SIZE; iArrayIndex++)
            {   // Free the objects that are no longer used
                this.freeElement(m_aRecords[iArrayIndex]);
                m_aRecords[iArrayIndex] = null;
            }
            m_aRecords = null;
        }
        m_iRecordListStep = 1;
        m_iRecordListEnd = 0;
        m_iRecordListMax = 0; // Current size of the record list (records scanned) (-1 - unknown)
    }
1151208
def clear(self):
        
        self._objects.clear()
        self._class_aliases = {}
        self._unicodes = {}
        self.extra = {}
207580
def clear_data(self):
        
        if (self.get_data_metadata().is_read_only() or
                self.get_data_metadata().is_required()):
            raise errors.NoAccess()
        if self._my_map['data'] == self._data_default:
            return
        dbase = JSONClientValidated('repository',
                                    runtime=self._runtime).raw()
        filesys = gridfs.GridFS(dbase)
        filesys.delete(self._my_map['data'])
        self._my_map['data'] = self._data_default
        del self._my_map['base64']
248957
public void clear() {
    FastHashtableEntry tab[] = table;
    for (int index = tab.length; --index >= 0; )
      tab[index] = null;
    count = 0;
  }
188429
def clear(self):
        
        self.grid = [[EMPTY for dummy_col in range(self.grid_width)] for dummy_row in range(self.grid_height)]
1015875
public function clear()
    {
        $this->id = null;
        $this->file = null;
        $this->person_id = null;
        $this->visible = null;
        $this->position = null;
        $this->created_at = null;
        $this->updated_at = null;
        $this->alreadyInSave = false;
        $this->clearAllReferences();
        $this->applyDefaultValues();
        $this->resetModified();
        $this->setNew(true);
        $this->setDeleted(false);
    }
29128
public function clear()
    {
        if (null !== $this->aPlayer) {
            $this->aPlayer->removeRecord($this);
        }
        $this->id = null;
        $this->mapuid = null;
        $this->nblaps = null;
        $this->score = null;
        $this->nbfinish = null;
        $this->avgscore = null;
        $this->checkpoints = null;
        $this->player_id = null;
        $this->created_at = null;
        $this->updated_at = null;
        $this->alreadyInSave = false;
        $this->clearAllReferences();
        $this->resetModified();
        $this->setNew(true);
        $this->setDeleted(false);
    }
361984
@Override
	public void clear() {
		super.clear();

		// currentSchema = null;
		dataSets = new HashSet<>();
		generatedDaos = null;
		generatedEntities = null;
		globalDaoElements.clear();
		schemas = new LinkedHashSet<>();
	}
455740
public void clear() {
		columnLookup.clear();
		rowLookup.clear();
		data = null;
		dataGrid.clear();
		doubleValues.clear();
		System.gc();
	}
1193846
def clear(self):
        
        self._filters = []
        self._order_by = OrderedDict()
        self._selects = set()
        self._negation = False
        self._attribute = None
        self._chain = None
        self._search = None

        return self
540825
public function clearValues()
    {
        foreach ($this->record as $key => $value) {
            $this->record[$key] = null;
        }
    }
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()
51718
def removeDataFrameRows(self, rows):
        
        if not self.editable:
            return False

        if rows:
            position = min(rows)
            count = len(rows)
            self.beginRemoveRows(QtCore.QModelIndex(), position, position + count - 1)

            removedAny = False
            for idx, line in self._dataFrame.iterrows():
                if idx in rows:
                    removedAny = True
                    self._dataFrame.drop(idx, inplace=True)

            if not removedAny:
                return False

            self._dataFrame.reset_index(inplace=True, drop=True)

            self.endRemoveRows()
            return True
        return False
617168
public static void clear() {
		for (int i = 0; i < index; ++i) {
			instances.get(i).clear();
		}
		index = 0;
	}
1345186
def clear(self):
        
        model = self.tree.model()
        # Don't use model.clear(). it will delete the column sizes
        model.removeRows(0, 1)
        model.setRowCount(1)
        self._setColumnCountForContents()
890943
public function clear()
    {
        $this->id = null;
        $this->feature_id = null;
        $this->feature_type_id = null;
        $this->alreadyInSave = false;
        $this->clearAllReferences();
        $this->resetModified();
        $this->setNew(true);
        $this->setDeleted(false);
    }