Reset mapper for thrift.

@param isCql3Enabled
the is cql3 enabled
763604
private static void resetMapperForThrift(boolean isCql3Enabled)
    {
        if (isCql3Enabled)
        {
            validationClassMapper.put(Byte.class, BytesType.class);
            validationClassMapper.put(byte.class, BytesType.class);
            validationClassMapper.put(Short.class, IntegerType.class);
            validationClassMapper.put(short.class, IntegerType.class);
            validationClassMapper.put(java.sql.Time.class, DateType.class);
            validationClassMapper.put(java.sql.Date.class, DateType.class);
            validationClassMapper.put(java.util.Date.class, DateType.class);
            validationClassMapper.put(java.sql.Timestamp.class, DateType.class);
        }
    }
167297
public void reset() {

        if (refCount.get() > 0 && isRefCountingEnabled()) {
            Tr.warning(tc, "reset called on " + id + " with a refCount of " + refCount);
            Thread.dumpStack();
        }

        cacheName = null;
        drsClock = -1;
        timeStamp = -1;
        serializedId = null;
        id = null;
        if (useByteBuffer && this.value != null) {
            if (this.value instanceof DistributedNioMapObject) {
                ((DistributedNioMapObject) this.value).release();
            }
        }
        serializedValue = null;
        value = null;
        clock = CacheConfig.DEFAULT_PRIORITY;
        refCount.set(0);
        priority = CacheConfig.DEFAULT_PRIORITY;
        timeLimit = -1;
        inactivity = -1;
        expirationTime = -1;
        validatorExpirationTime = -1;
        removeWhenUnpinned = false;
        _templates = EMPTY_STRING_ARRAY;
        _dataIds = EMPTY_OBJECT_ARRAY;
        _serializedDataIds = null;
        pendingRemoval = false;
        sharingPolicy = EntryInfo.NOT_SHARED;
        persistToDisk = true;
        isOverflowEntry = false;
        lruEvicted = false;
        lruHead = null;
        useByteBuffer = false;
        aliasList = EMPTY_OBJECT_ARRAY;
        serializedAliasList = null;
        userMetaData = null;
        serializedUserMetaData = null;
        loadedFromDisk = false;
        cacheType = CACHE_TYPE_DEFAULT;
        skipValueSerialized = false;
        skipMemoryAndWriteToDisk = false;
        skipMemoryAndWriteToDiskErrorCode = HTODDynacache.NO_EXCEPTION;
        valueHashcode = 0;
        externalCacheGroupId = null;
    }
938995
public WritableByteChannel reset(WritableByteChannel channel)
            throws IOException
    {
        WritableByteChannel old = this.channel;
        this.channel = channel;
        return old;
    }
1350051
public void resetDatabase() {

        String dropOrphanedEvents = "DROP TABLE IF EXISTS " + DbOrphanedEvent.TABLE_NAME;

        SQLiteDatabase writable = dbHelper.getWritableDatabase();

        writable.beginTransaction();

        try {

            writable.execSQL(dropOrphanedEvents);
            writable.execSQL(DatabaseHelper.SQL_CREATE_ORPHANED_EVENTS_TABLE);
            writable.setTransactionSuccessful();

        } finally {
            writable.endTransaction();
            log.d("Chat database reset.");
        }
    }
253258
private void reset() {
    size = 0;
    qualifier_index = 0;
    value_index = 0;
    base_time = Long.MIN_VALUE;
    last_timestamp = Long.MIN_VALUE;
  }
747992
public void resetCursor() 
  throws SISessionUnavailableException, SISessionDroppedException,
         SIErrorException, SIIncorrectCallException
  {
    if (TraceComponent.isAnyTracingEnabled() && CoreSPILockedMessageEnumeration.tc.isEntryEnabled())
      SibTr.entry(CoreSPILockedMessageEnumeration.tc, "resetCursor", this);
          
    checkValidState("resetCursor");
          
    _localConsumerPoint.checkNotClosed();
    
    _seenSingleMessage = false;
    
    if (TraceComponent.isAnyTracingEnabled() && CoreSPILockedMessageEnumeration.tc.isEntryEnabled())
      SibTr.exit(CoreSPILockedMessageEnumeration.tc, "resetCursor");
  }
608239
void resetForRetry() {
    startTime = -1L;
    startNanos = -1L;
    latency = -1L;
    result = null;
    status = null;
    statusDetail = null;
    exception = null;
    attempt = null;
    attemptFinal = null;
    vip = null;
    serverRegion = null;
    serverZone = null;
    serverApp = null;
    serverCluster = null;
    serverAsg = null;
    serverNode = null;
    httpStatus = -1;
    requestHeaders.clear();
    responseHeaders.clear();
    remoteAddress = null;
    remotePort = -1;
    builder.delete(0, builder.length());
    inflightId = null;
  }
223811
@Override
    public void reset() {
        if (!iter.resetSupported()) {
            throw new IllegalStateException(
                            "Cannot reset MultipleEpochsIterator with base iter that does not support reset");
        }
        epochs = 0;
        lastBatch = batch;
        batch = 0;
        iterationsCounter.set(0);
        iter.reset();
    }
137937
public void reset()
    {
        if (_refs != null) {
            _refs.clear();
            _refCount = 0;
        }

        _classRefs.clear();
        _typeRefs = null;
        _offset = 0;
        _isPacket = false;
        _isUnshared = false;
    }
1303340
protected void reset()
    {
        this.active = false;
        synchronized (this.cachedChannelsNonTransactional)
        {
            for (ChannelProxy channel : this.cachedChannelsNonTransactional)
            {
                try
                {
                    channel.getTargetChannel().close();
                }
                catch (Throwable ex)
                {
                    this.logger.trace("Could not close cached Rabbit Channel", ex);
                }
            }
            this.cachedChannelsNonTransactional.clear();
        }
        synchronized (this.cachedChannelsTransactional)
        {
            for (ChannelProxy channel : this.cachedChannelsTransactional)
            {
                try
                {
                    channel.getTargetChannel().close();
                }
                catch (Throwable ex)
                {
                    this.logger.trace("Could not close cached Rabbit Channel", ex);
                }
            }
            this.cachedChannelsTransactional.clear();
        }
        this.active = true;
    }
335561
@Override
    public void delete(Object entity, Object pKey)
    {
        if (!isOpen())
        {
            throw new PersistenceException("ThriftClient is closed.");
        }

        EntityMetadata metadata = KunderaMetadataManager.getEntityMetadata(kunderaMetadata, entity.getClass());
        Connection conn = null;
        try
        {
            conn = getConnection();
            MetamodelImpl metaModel = (MetamodelImpl) kunderaMetadata.getApplicationMetadata().getMetamodel(
                    metadata.getPersistenceUnit());

            AbstractManagedType managedType = (AbstractManagedType) metaModel.entity(metadata.getEntityClazz());
            // For secondary tables.
            List<String> secondaryTables = ((DefaultEntityAnnotationProcessor) managedType.getEntityAnnotation())
                    .getSecondaryTablesName();
            secondaryTables.add(metadata.getTableName());

            for (String tableName : secondaryTables)
            {
                if (isCql3Enabled(metadata))
                {
                    String deleteQuery = onDeleteQuery(metadata, tableName, metaModel, pKey);
                    executeCQLQuery(deleteQuery, isCql3Enabled(metadata));

                }
                else
                {
                    if (metadata.isCounterColumnType())
                    {
                        deleteRecordFromCounterColumnFamily(pKey, tableName, metadata, getConsistencyLevel());
                    }
                    else
                    {
                        ColumnPath path = new ColumnPath(tableName);

                        conn.getClient().remove(
                                CassandraUtilities.toBytes(pKey, metadata.getIdAttribute().getJavaType()), path,
                                generator.getTimestamp(), getConsistencyLevel());
                    }
                }
            }
            getIndexManager().remove(metadata, entity, pKey);

            // Delete from Inverted Index if applicable
            invertedIndexHandler.delete(entity, metadata, getConsistencyLevel(), kunderaMetadata);
        }
        catch (InvalidRequestException e)
        {
            log.error("Error while deleting of column family {} for row key {}, Caused by: .", metadata.getTableName(),
                    pKey, e);
            throw new KunderaException(e);
        }
        catch (TException e)
        {
            log.error("Error while deleting of column family {} for row key {}, Caused by: .", metadata.getTableName(),
                    pKey, e);
            throw new KunderaException(e);
        }
        finally
        {
            releaseConnection(conn);
        }
    }
492538
static void reset() {
        WarpContext context = reference.get();
        Validate.notNull(context, "WarpContext in store can't be null when resetting");
        reference.compareAndSet(context, null);
    }
1193140
public synchronized void reset() throws BlockStoreException {
        try {
            WriteBatch batch = db.createWriteBatch();
            try {
                DBIterator it = db.iterator();
                try {
                    it.seekToFirst();
                    while (it.hasNext())
                        batch.delete(it.next().getKey());
                    db.write(batch);
                } finally {
                    it.close();
                }
            } finally {
                batch.close();
            }
            initStoreIfNeeded();
        } catch (IOException e) {
            throw new BlockStoreException(e);
        }
    }
448374
public synchronized void reset() {
		timeoutAt = 0;
		prevSeq = -1;
		pool.clear();
		stream.closed.set(false);
		stream.buffer.clear();
		stream.cause = null;
		stream.transferedBytes.set(0);
		inited.set(false);
	}
1303916
def _reset(self):
        
        # Reset DataContainer to default values
        # So that it can be reused
        if self.logger: # pragma: no cover
            self.logger.info("Reset DataContainer")
        self._items_list = []
        self._config.data_type = None
1192505
public void reset() throws IOException {
        synchronized (lock) {
            ensureOpen();
            if (markedChar < 0)
                throw new IOException((markedChar == INVALIDATED)
                                      ? "Mark invalid"
                                      : "Stream not marked");
            nextChar = markedChar;
            skipLF = markedSkipLF;
        }
    }
690208
public Where<T, ID> reset() {
		for (int i = 0; i < clauseStackLevel; i++) {
			// help with gc
			clauseStack[i] = null;
		}
		clauseStackLevel = 0;
		return this;
	}