Add this key and value to the cache.
@param objKey The raw key value.
@param objValue The data value to associate with this key.
19534
public void cacheValue(Object objKey, Object objValue)
    {
//x        if ((objKey == null) || (objValue == null))
        if (objKey == null)
            return;
        Class<?> classKey = this.getField().getDataClass();
        objKey = this.convertKey(objKey, classKey);
        if (m_hmCache == null)
            m_hmCache = new HashMap<Object,Object>();
        m_hmCache.put(objKey, objValue);
    }
372563
public void store(K key, V object) {
		if (isCachingEnabled()) {
			CachedObject<V> co = new CachedObject<V>(object);
			storeCachedObject(key, co);
		}
	}
663173
public static final void setValue(Object obj, String fieldName, 
            Object value) {
        try {
            getField(obj.getClass(), fieldName).set(obj, value);
        } catch (IllegalArgumentException e) {
            throw new RuntimeException(e);
        } catch (IllegalAccessException e) {
            throw new RuntimeException(e);
        }
    }
949550
@Override
	public void put(String key, Object obj) {

		cache.put(new Element(key, obj));
	}
134828
public void addTable(Object objKey, BaseTable table)
    {
        if (m_mapTable == null)
            m_mapTable = new Hashtable<Object,BaseTable>();
        if (objKey == null)
            objKey = new Integer(m_mapTable.size());
        m_mapTable.put(objKey, table);
    }
485904
public VALUE put(KEY key, VALUE object) {
        CacheEntry<VALUE> entry;
        if (referenceType == ReferenceType.WEAK) {
            entry = new CacheEntry<>(new WeakReference<>(object), null);
        } else if (referenceType == ReferenceType.SOFT) {
            entry = new CacheEntry<>(new SoftReference<>(object), null);
        } else {
            entry = new CacheEntry<>(null, object);
        }

        countPutCountSinceEviction++;
        countPut++;
        if (isExpiring && nextCleanUpTimestamp == 0) {
            nextCleanUpTimestamp = System.currentTimeMillis() + expirationMillis + 1;
        }

        CacheEntry<VALUE> oldEntry;
        synchronized (this) {
            if (values.size() >= maxSize) {
                evictToTargetSize(maxSize - 1);
            }
            oldEntry = values.put(key, entry);
        }
        return getValueForRemoved(oldEntry);
    }
91517
public synchronized void insert(Object key, Object value) {
        // evict until size < maxSize
        while (isEvictionRequired() && entryLimit > 0 && entryLimit < Integer.MAX_VALUE) {
            evictStaleEntries();
        }

        Entry curEntry = new Entry(value);
        Entry oldEntry = (Entry) primaryTable.put(key, curEntry);

        if (oldEntry != null && oldEntry.value != null) {
            ArrayList<Object> evictedValues = new ArrayList<Object>();
            evictedValues.add(oldEntry.value);
            for (CacheEvictionListener evictionCallback : cacheEvictionListenerSet) {
                evictionCallback.evicted(evictedValues);
            }
        }
    }
885000
public void addDatabaseProperty(String strKey, String strValue)
    {
        this.setProperty(strKey, strValue);
        Environment env = (Environment)this.getDatabaseOwner().getEnvironment();
        if (env.getCachedDatabaseProperties(this.getDatabaseName(true)) != null)  // Always
            if (env.getCachedDatabaseProperties(this.getDatabaseName(true)) != Environment.DATABASE_DOESNT_EXIST)  // Always
                env.getCachedDatabaseProperties(this.getDatabaseName(true)).put(strKey, strValue);
    }
266129
public boolean setCache(Object objTargetRow, Object data)
    {
        if (objTargetRow != NONE)
        {
            if (m_mapCache != null)
            {
                int iTargetRow = ((Integer)objTargetRow).intValue();
                int iCurrentPhysicalRecord = ((Integer)m_objCurrentPhysicalRecord).intValue();
                if (iTargetRow == iCurrentPhysicalRecord)
                {   // Reset the current record
                    m_objCurrentPhysicalRecord = NONE;
                    m_objCurrentCacheRecord = NONE;
                    m_objCurrentLockedRecord = NONE;
                }
                if (m_iPhysicalLastRecordPlusOne == iTargetRow)
                    m_iPhysicalLastRecordPlusOne++;
                m_mapCache.set(iTargetRow, data); // Make sure the cache matches the actual
                return true;
            }
            if (m_htCache != null)
            {
                if (objTargetRow.equals(m_objCurrentPhysicalRecord))
                {   // Reset the current record.
                    m_objCurrentPhysicalRecord = NONE;
                    m_objCurrentCacheRecord = NONE;
                    m_objCurrentLockedRecord = NONE;
                }
                if (data != null)
                    m_htCache.put(objTargetRow, data);  // Make sure the cache matches the actual
                else
                    m_htCache.remove(objTargetRow);
                return true;
            }
        }
        return false; // nothing updated
    }
1214451
protected void addToCache(K canonicalKey, R row) {
		assert ObjectUtils.equals(canonicalize(row.getKey()), canonicalKey);
		rowCache.get().put(canonicalKey, row);
	}
1157095
public void addValue(ByteBuffer key, ByteBuffer value) {
    if (isFull) {
      throw new IllegalArgumentException("Already full");
    }
    if (value.remaining() + key.remaining() + POINTER_SIZE_BYTES > memoryBuffer.remaining()) {
      leftover = new KeyValue<>(key, value);
      isFull = true;
    } else {
      int keyPos = spliceIn(key, memoryBuffer);
      int valuePos = spliceIn(value, memoryBuffer);
      addPointer(keyPos, key.remaining(), valuePos, value.remaining());
    }
  }
422640
public void put(String key, String value) {
        synchronized (this.cache) {
            this.cache.put(key, value);
        }
    }
649174
protected function putDefaultStorageValue($sKey, $obValue)
    {
        if (empty($this->obDefaultStorage)) {
            return;
        }

        $this->obDefaultStorage->put($sKey, $obValue);
    }
330979
void writeObjectKeyValue(String key, String value) throws IOException {
        writeObjectKey(key);
        writeString(value);
    }
719261
public void setControlValue(Object objValue)
    {
        if (objValue != null)
            this.setText(objValue.toString());
        else
            this.setText(null);
    }
109727
public static void putProperty(Scriptable obj, Symbol key, Object value)
    {
        Scriptable base = getBase(obj, key);
        if (base == null)
            base = obj;
        ensureSymbolScriptable(base).put(key, obj, value);
    }
1155913
public void addValue(Object current, Object value) throws ParseException, IOException {
		// if (obj != null)
		mapper.addValue(current, value);
	}