set the value of the cache object.

@param cacheKey the key
@param value    the value
@return complete or error.
199481
public static Completable set(String cacheKey, Object value) {
        return set(CacheService.CACHE_CONFIG_BEAN, cacheKey, value);
    }
186655
public function resetCacheKey($cacheKey, $value = false)
    {
        $cache = $this->getCache();
        if ($cache) {
            return $this->getCache()->set($cacheKey, $value);
        }
        return false;
    }
1114121
public S setParameter(String key, String value) {
        if (parameters == null) {
            parameters = new ConcurrentHashMap<String, String>();
        }
        if (value == null) {
            parameters.remove(key);
        } else {
            parameters.put(key, value);
        }
        return castThis();
    }
568903
public boolean hasCachedValue(Key key) {
		try {
			readLock.lock();
			return content.containsKey(key);
		} finally {
			readLock.unlock();
		}
	}
652637
protected function setToCache($cacheKey, $value, $ttl = null)
    {
        // Seralize as JSON to ensure array etc can be stored
        $value = Convert::raw2json($value);

        return $this->getCache()->set($cacheKey, $value, $ttl);
    }
954668
public static Map<CacheMode, Long> cacheModeMapFor(long value) {
        if (value == 0) {
            return CACHE_MODE_ALL_ZEROS;
        }
        Map<CacheMode, Long> m = new HashMap<>();
        for (CacheMode cm : CacheMode.values()) {
            m.put(cm, value);
        }
        return m;
    }
913883
public static Single<Long> incrementByValue(String cacheKey, long value) {
        return incrementByValue(CacheService.CACHE_CONFIG_BEAN, cacheKey, value);
    }
479022
public function cacheSet($key, $value)
    {
        return $this->cache() ? $this->cache()->set($key, $value) : null;
    }
338012
public function setCache($key, $value) {
        if($this->cacheEnabled) {
            $this->cacheObj->save($key, $value);
        }
    }
856320
public static <T> Single<Set<T>> values(CacheConfigBean cacheConfigBean, String key, Class<T> vClazz) {
        return values(cacheConfigBean, key)
                .map(values -> {
                    Set<T> _values = new TreeSet<>();
                    if (values != null && !values.isEmpty()) {
                        values.forEach(value -> {
                            _values.add(Reflection.toType(value, vClazz));
                        });
                    }
                    return _values;
                });
    }
806381
public static <T> Single<Set<T>> values(String key, Class<T> vClazz) {
        return values(CacheService.CACHE_CONFIG_BEAN, key, vClazz);
    }
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);
    }
707452
public function setCache($key, $value) {
        $this->_cache[$this->createCacheKey($key)] = $value;

        return $value;
    }
765435
function mapCacheSet(key, value) {
  var data = _getMapData(this, key),
      size = data.size;

  data.set(key, value);
  this.size += data.size == size ? 0 : 1;
  return this;
}
1220688
public static Maybe<List<String>> values(CacheConfigBean cacheConfigBean, String key) {
        return SingleRxXian
                .call(CacheService.CACHE_SERVICE, "cacheMapValues", new JSONObject() {{
                    put("cacheConfig", cacheConfigBean);
                    put("key", key);
                }})
                .flatMapMaybe(unitResponse -> {
                    unitResponse.throwExceptionIfNotSuccess();
                    if (unitResponse.getData() == null)
                        return Maybe.empty();
                    else
                        return Maybe.just(Reflection.toTypedList(unitResponse.getData(), String.class));
                });
    }
726450
public static Single<Long> remove(String cacheKey, Object value) {
        return remove(CacheService.CACHE_CONFIG_BEAN, cacheKey, value);
    }
895363
public void put(Object key, Object value) {
		if ((key == null) || (value == null))
			return;

		try {
			if (maxSize > 0) {
				// when maxSize is changed, the setter will take care of filling
				// the
				// LRU list
				if (cacheLineTable.containsKey(key)) {
					keyLRUList.moveFirst(key);
				} else {
					keyLRUList.addFirst(key);
				}
			}

			if (expireTime > 0) {
				cacheLineTable.put(key, new CacheLine(value, useSoftReference, System.currentTimeMillis()));
			} else {
				cacheLineTable.put(key, new CacheLine(value, useSoftReference));
			}
			if (maxSize > 0 && cacheLineTable.size() > maxSize) {
				Object lastKey = keyLRUList.getLast();
				removeObject(lastKey);
			}
		} catch (Exception e) {
			Debug.logError(e);
		} finally {
		}
		Debug.logVerbose("[JdonFramework]cache now size = " + keyLRUList.size() + " maxSize =" + maxSize + " this Cache id:" + this.hashCode(),
				module);
	}