Call this method when a cache id is retrieved from one of invalidation buffers. The entry is being used to remove
from the disk using LPBT.

@param bufferType
- specify the invalidation buffer.
@return Object cache id.
482551
protected synchronized Object get(int bufferType) {
        // final String methodName = "get(boolean)";
        Object id = null;
        if (bufferType == this.EXPLICIT_BUFFER) {
            if (!this.explicitBuffer.isEmpty()) {
                Set s = this.explicitBuffer.keySet();
                Iterator it = s.iterator();
                ExplicitIdData idData = new ExplicitIdData();
                while (it.hasNext()) {
                    idData.id = it.next();
                    idData.info = ((Byte) this.explicitBuffer.get(idData.id)).byteValue();
                    if ((idData.info & HTODInvalidationBuffer.STATUS_ALIAS) == 0) {
                        id = idData;
                        break;
                    }
                }
            }
        } else if (bufferType == this.SCAN_BUFFER) {
            if (!this.scanBuffer.isEmpty()) {
                id = this.scanBuffer.getOne();
            }
        } else if (bufferType == this.GC_BUFFER) {
            if (!this.garbageCollectorBuffer.isEmpty()) {
                // Always get the first one from the list
                id = this.garbageCollectorBuffer.get(0);
            }
        }

        // if (id != null) {
        // traceDebug(methodName, "cacheName=" + this.cod.cacheName + " id=" + id + " bufferType=" + bufferType);
        // }
        return id;
    }
1259740
public static AttributeType get(final long _id)
        throws CacheReloadException
    {
        final Cache<Long, AttributeType> cache = InfinispanCache.get().<Long, AttributeType>getCache(
                        AttributeType.IDCACHE);
        if (!cache.containsKey(_id)) {
            AttributeType.getAttributeTypeFromDB(AttributeType.SQL_ID, _id);
        }
        return cache.get(_id);
    }
652667
public Type getParentType()
    {
        Type ret = null;
        if (this.parentTypeId != null && this.parentTypeId != 0) {
            try {
                ret = Type.get(this.parentTypeId);
            } catch (final CacheReloadException e) {
                Type.LOG.error("Could not read parentType for id: {}", this.parentTypeId);
            }
        }
        return ret;
    }
520644
public Set<Type> getTypes()
        throws CacheReloadException
    {
        final Set<Type> ret = new HashSet<>();
        for (final Long id : this.types) {
            ret.add(Type.get(id));
        }
        return Collections.unmodifiableSet(ret);
    }
520551
public com.ibm.websphere.cache.CacheEntry getEntry(Object id) {
        return getEntry(id, CachePerf.LOCAL, IGNORE_COUNTING, !INCREMENT_REFF_COUNT);
    }
1098780
@Override
    public synchronized Object getValue() {
        if (id != null) {
            if (serializedValue != null) {
                long oldSize = -1;
                if (cacheEntryPool != null) {
                    if (cacheEntryPool.cache.isCacheSizeInMBEnabled()) {
                        oldSize = getObjectSize();
                    }
                }

                try {
                    value = SerializationUtility.deserialize(serializedValue, cacheName);
                } catch (Exception ex) {
                    com.ibm.ws.ffdc.FFDCFilter.processException(ex, "com.ibm.ws.cache.CacheEntry.getValue", "200", this);
                }
                if (value != null) {
                    serializedValue = null;
                    if (cacheEntryPool != null) {
                        if (cacheEntryPool.cache.isCacheSizeInMBEnabled()) {
                            long newSize = getObjectSize();
                            if (oldSize != -1 && newSize != -1) {
                                cacheEntryPool.cache.increaseCacheSizeInBytes(newSize - oldSize, "GET_VALUE");
                            } else {
                                cacheEntryPool.cache.disableCacheSizeInMB();
                            }
                        }
                    }
                }
            }
        }
        return value;
    }
605164
@Override
    public byte[] getBuffer () {
        synchronized ( this.cache ) {
            byte[] buf;

            if ( this.freeBuffers > 0 ) {
                for ( int i = 0; i < this.cache.length; i++ ) {
                    if ( this.cache[ i ] != null ) {
                        buf = (byte[]) this.cache[ i ];
                        this.cache[ i ] = null;
                        this.freeBuffers--;
                        return buf;
                    }
                }
            }
            return new byte[this.bufferSize];
        }
    }
120385
public long getInstanceId() {
        HprofByteBuffer dumpBuffer = classDump.getHprofBuffer();
        return dumpBuffer.getID(fileOffset + classDump.classDumpSegment.fieldValueOffset);
    }
771893
@Override
    public String getCacheEntry(String cacheInstance, String cacheId) throws javax.management.AttributeNotFoundException { // 429429       

        if (cacheId == null) {
            throw new AttributeNotFoundException(cacheId + " is null.");
        }

        //Get the cache for this cacheInstance
        DCache cache1 = getCache(cacheInstance);
        //Get the cache entry

        EntryInfo ei = new EntryInfo();
        ei.setId(cacheId);
        com.ibm.websphere.cache.CacheEntry cacheEntry = cache1.getEntry(ei, true);

        String stringEntry = null;
        if (null != cacheEntry) {
            stringEntry = cacheEntry.toString();
            // Release cacheEntry and decrement referenced count for it before
            // return.
            cacheEntry.finish();
        }

        if (tc.isDebugEnabled()) {
            Tr.debug(tc, "getCacheEntry: Returning: " + stringEntry
                         + " for cacheInstance = " + cacheInstance);
        }

        return stringEntry;
    }
339043
public static AccessType getAccessType(final long _id)
        throws CacheReloadException
    {
        final Cache<Long, AccessType> cache = InfinispanCache.get().<Long, AccessType>getCache(AccessType.IDCACHE);
        if (!cache.containsKey(_id)) {
            AccessType.getAccessTypeFromDB(AccessType.SQL_ID, _id);
        }
        return cache.get(_id);
    }
906962
public String getKey() {
		StringBuilder buffer = new StringBuilder(cacheType);
		buffer.append(dataTypeName);
		if (dataKey != null)
			buffer.append(dataKey.toString());
		return buffer.toString().intern();
	}
1026412
public InstanceId restoreFromBuffer(ByteBuffer buf)
            throws IOException
    {
        buf.rewind();

        // Assumes config data is the last field.
        int dataSize = buf.remaining() - OFFSET_DATA;
        if (dataSize <= 0) {
            throw new IOException("Hashinator snapshot data is too small.");
        }

        // Get the CRC, zero out its buffer field, and compare to calculated CRC.
        long crcHeader = buf.getLong(OFFSET_CRC);
        buf.putLong(OFFSET_CRC, 0);
        final PureJavaCrc32 crcBuffer = new PureJavaCrc32();
        assert(buf.hasArray());
        crcBuffer.update(buf.array());
        if (crcHeader != crcBuffer.getValue()) {
            throw new IOException("Hashinator snapshot data CRC mismatch.");
        }

        // Slurp the data.
        int coord = buf.getInt(OFFSET_INSTID_COORD);
        long timestamp = buf.getLong(OFFSET_INSTID_TIMESTAMP);
        InstanceId instId = new InstanceId(coord, timestamp);
        m_version = buf.getLong(OFFSET_VERSION);
        m_serData = new byte[dataSize];
        buf.position(OFFSET_DATA);
        buf.get(m_serData);

        return instId;
    }
348016
public Type getParameterizedType() {
        Type tmp = parameterTypeCache;
        if (null == tmp) {
            tmp = executable.getAllGenericParameterTypes()[index];
            parameterTypeCache = tmp;
        }

        return tmp;
    }
846840
public CacheEntry getEntryDisk(Object cacheId) {
		CacheEntry cacheEntry = new CacheEntry(cacheInstance.getEntryDisk(cacheId));	 
		return cacheEntry;
	}
289165
protected void invalidateCache(T bo, CacheInvalidationReason reason) {
        final String cacheKey = cacheKey(bo);
        switch (reason) {
        case CREATE:
        case UPDATE:
            putToCache(getCacheName(), cacheKey, bo);
        case DELETE:
            removeFromCache(getCacheName(), cacheKey);
        }
    }
1252941
private <T> T getInstance(DatastoreType datastoreType, TransactionalCache.Mode cacheMode) {
        DatastoreId id = getDatastoreId(datastoreType);
        Object instance = cache.get(id, cacheMode);
        if (instance == null) {
            DynamicType<?> types = getTypes(datastoreType);
            instance = newInstance(id, datastoreType, types, cacheMode);
            if (TransactionalCache.Mode.READ.equals(cacheMode)) {
                instanceListenerService.postLoad(instance);
            }
        }
        return (T) instance;
    }
768031
public CacheEntry filterEntry(String cacheName, CacheEntry cacheEntry) {
		
		InvalidationTableList invalidationTableList = getInvalidationTableList(cacheName);
		try {
			invalidationTableList.readWriteLock.readLock().lock();
			return internalFilterEntry(cacheName, invalidationTableList, cacheEntry);
		} finally {
			invalidationTableList.readWriteLock.readLock().unlock();
		}
	}