Returns a filtered version of the DynamicMap cache leaving only
        keys consistently with the newly specified values
332314
def _filter_cache(self, dmap, kdims):
        
        filtered = []
        for key, value in dmap.data.items():
            if not any(kd.values and v not in kd.values for kd, v in zip(kdims, key)):
                filtered.append((key, value))
        return filtered
1147126
def filter_keys(self, **kwargs):
        ""
        self._used_index = False
        keys = set(self.data.keys())
        for key_filter, v_filter in kwargs.items():
            if key_filter in self.indexes:
                self._used_index = True
                if v_filter not in self.indexes[key_filter]:
                    keys = set([])
                else:
                    keys = keys.intersection(
                        self.indexes[key_filter][v_filter])
            else:
                keys = keys.intersection(
                    self.simple_filter(key_filter, v_filter))
        return keys
831744
@SuppressWarnings("unchecked")
	public <T> Map<Serializable, T> get(Collection<? extends Serializable> keys) {
		Map<Serializable, T> result = Maps.newHashMapWithExpectedSize(keys.size());
		for (Serializable key : keys) {
			T value = (T) contents.getIfPresent(key);
			if (value != null) {
				result.put(key, value);
			}
		}
		if (log.isDebugEnabled() && !result.isEmpty()) {
			log.debug("Level 1 cache multiple hit: {}", result.keySet());
		}
		return result;
	}
1219756
def get_dynamic_mode(composite):
    ""
    dynmaps = composite.traverse(lambda x: x, [DynamicMap])
    holomaps = composite.traverse(lambda x: x, ['HoloMap'])
    dynamic_unbounded = any(m.unbounded for m in dynmaps)
    if holomaps:
        validate_unbounded_mode(holomaps, dynmaps)
    elif dynamic_unbounded and not holomaps:
        raise Exception("DynamicMaps in unbounded mode must be displayed alongside "
                        "a HoloMap to define the sampling.")
    return dynmaps and not holomaps, dynamic_unbounded
852550
function filter(mMap, fnFilter) {
			return Object.keys(mMap).filter(fnFilter).reduce(copyTo.bind(mMap), {});
		}
181525
@Override
	public <T> List<T> dynamicQuery(DynamicQuery dynamicQuery) {
		return cpFriendlyURLEntryPersistence.findWithDynamicQuery(dynamicQuery);
	}
858483
@SuppressWarnings("unchecked")
	private String genarateQueryCacheKey(String keyPattern,Object param){
		if(param instanceof Map){
			Map<String, Object> map = (Map<String, Object>) param;
			Object[] args = new String[map.size()/2];
			if(map.containsKey(STR_COLLECTION) || map.containsKey(STR_LIST)){
				args[0] = CacheKeyUtils.toString(map.containsKey(STR_COLLECTION) ? map.get(STR_COLLECTION) : map.get(STR_LIST));
			}else{				
				for (int i = 0; i < args.length; i++) {
					args[i] = CacheKeyUtils.toString(map.get(STR_PARAM + (i+1)));
				}
			}
			return String.format(keyPattern, args);
		}else if(param instanceof BaseEntity){
			Serializable id = ((BaseEntity)param).getId();
			if(id != null && !"0".equals(id.toString())){				
				return String.format(keyPattern, ((BaseEntity)param).getId());
			}else{
				return String.format(keyPattern, CacheKeyUtils.toString(param));
			}
		}else if(param instanceof Object[]){
			return String.format(keyPattern, (Object[])param);
		}else{
			return param == null ? keyPattern : String.format(keyPattern, CacheKeyUtils.toString(param));
		}
	}
276658
function filterByKeys(keys, values) {
  var filtered = {};

  forEach(keys, function (name) {
    filtered[name] = values[name];
  });
  return filtered;
}
229878
@Override
	public <T> List<T> dynamicQuery(DynamicQuery dynamicQuery) {
		return commerceCountryPersistence.findWithDynamicQuery(dynamicQuery);
	}
143204
@Override
	public <T> List<T> dynamicQuery(DynamicQuery dynamicQuery) {
		return cpDefinitionVirtualSettingPersistence.findWithDynamicQuery(dynamicQuery);
	}
1056125
@Override
	public <T> List<T> dynamicQuery(DynamicQuery dynamicQuery) {
		return commerceUserSegmentEntryPersistence.findWithDynamicQuery(dynamicQuery);
	}
208515
public static Map<String, Object> filter(Map<String, Object> source, String prefix, String include, String exclude, Map<String, String> keyMap) {
    	LinkedHashMap<String, Object> dst = new LinkedHashMap<String, Object>();
    	if (source == null || source.isEmpty())
    		return dst;
    	Pattern includePattern = include == null ? null : Pattern.compile(include);
    	Pattern excludePattern = exclude == null ? null : Pattern.compile(exclude);
    	
    	for (Entry<String, Object> en : source.entrySet()) {
    		String key = en.getKey();
    		if (prefix != null) {
    			if (key.startsWith(prefix))
    				key = key.substring(prefix.length());
    			else
    				continue;
    		}
    		if (includePattern != null && !includePattern.matcher(key).find())
    			continue;
    		if (excludePattern != null && excludePattern.matcher(key).find())
    			continue;
    		if (keyMap != null && keyMap.containsKey(key))
    			dst.put(keyMap.get(key), en.getValue());
    		else
    			dst.put(key, en.getValue());
		}
    	return dst;
    }
571987
private void cacheUniqueSelectRef(Object object, MappedStatement mt, String cacheKey) {
		Collection<QueryMethodCache> mcs = queryCacheMethods.get(mt.getId().substring(0, mt.getId().lastIndexOf(SPLIT_PONIT))).values();
		outter:for (QueryMethodCache methodCache : mcs) {
			if(methodCache.isPk || methodCache.groupRalated)continue;
			try {	
				Object[] cacheFieldValues = new Object[methodCache.fieldNames.length];
				for (int i = 0; i < cacheFieldValues.length; i++) {
					if(methodCache.fieldNames[i] == null)break outter;
					cacheFieldValues[i] = ReflectUtils.getObjectValue(object, methodCache.fieldNames[i]);
					if(cacheFieldValues[i] == null)continue outter;
				}
				String fieldCacheKey = genarateQueryCacheKey(methodCache.keyPattern , cacheFieldValues);
				
				cacheFieldRefKey(fieldCacheKey,cacheKey, methodCache.getExpire());
				if(logger.isDebugEnabled())logger.debug("_autocache_ method[{}] add ref cacheKey:{}",mt.getId(),fieldCacheKey);
			} catch (Exception e) {
				logger.warn("cacheUniqueSelectRef:"+cacheKey,e);
			}
		}
	}
195540
public Filter getFilter()
        throws CacheReloadException
    {
        final IWhere where = eqlStmt.getQuery().getWhere();
        final IOrder order = eqlStmt.getOrder();
        return Filter.get(where, order, getTypes().toArray(new Type[getTypes().size()]));
    }
330605
public static cacheforwardproxy[] get_filtered(nitro_service service, String filter) throws Exception{
		cacheforwardproxy obj = new cacheforwardproxy();
		options option = new options();
		option.set_filter(filter);
		cacheforwardproxy[] response = (cacheforwardproxy[]) obj.getfiltered(service, option);
		return response;
	}
880060
@Override
	public <T> List<T> dynamicQuery(DynamicQuery dynamicQuery) {
		return cpDefinitionPersistence.findWithDynamicQuery(dynamicQuery);
	}
571175
def getCachedDataKey(engineVersionHash, key):
		
		cacheFile = CachedDataManager._cacheFileForHash(engineVersionHash)
		return JsonDataManager(cacheFile).getKey(key)