Gets the filter.

@return the filter
@throws CacheReloadException the cache reload exception
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()]));
    }
741400
@Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain)
            throws IOException, ServletException {
        HttpServletResponse httpServletResponse = (HttpServletResponse) servletResponse;

        // set cache directives
        httpServletResponse.setHeader(HTTPCacheHeader.CACHE_CONTROL.getName(), "no-cache, no-store");
        httpServletResponse.setDateHeader(HTTPCacheHeader.EXPIRES.getName(), 0L);

        filterChain.doFilter(servletRequest, servletResponse);
    }
325937
public function getFilter()
    {
        if (null == $this->filter) {
            $this->filter = new Filter([
                'serviceLocator' => $this->getServiceLocator(),
                'id'             => $this->getId(),
            ]);
        }

        return $this->filter;
    }
1361127
public function getCache() 
    {

        // make sure filters are parsed again if cache expired
        if (file_exists($this->path) && (time()-filectime($this->path)) < 
            $this->config['expiration_time']) {
            $data = unserialize(file_get_contents($this->path));
              return $data;
        }

        return false;
    }
113574
public <T> T asSingleResult() {
		T javaObject = null;
		String cacheKey = getCacheKey();
		if (isCacheable() && transaction == null) {
			Collection<Key> keys = getCacheManager().get(cacheNamespace, cacheKey);
			if (keys != null && keys.size() > 0) {
				Key key = keys.iterator().next();
				try {
					javaObject = (T) entityManager.get(key);
				} catch (EntityNotFoundException e) {
					throw new InconsistentCacheException("Entity Key " + key + " found in the cache but not in the Datastore");
				}
			}
		}
		if (javaObject == null) {
			Entity entity = getDatastoreService().prepare(query).asSingleEntity();
			if (entity == null) {
				throw new org.simpleds.exception.EntityNotFoundException("No " + getKind() + " found with " + getFilterPredicates());
			}
			javaObject = (T) entityManager.datastoreToJava(entity);
			if (isCacheable()) {
                populateCache(cacheKey, ImmutableList.of(entity.getKey()));
			}
		}
		return javaObject;

	}
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;
	}
453826
public Filter getFilter(ServletConfig servletConfig) throws ServletException {
        synchronized (filterCache) {
            Filter f = filterCache.get(servletConfig);
            if (f == null) {
                DefaultConfigurableFilterConfig filterConfig = new DefaultConfigurableFilterConfig(servletConfig);
                f = factory.createFilter(filterConfig);
                if (maintainLifeCycle) {
                    f.init(filterConfig);
                }
                filterCache.put(servletConfig, f);
            }
            return f;
        }

    }
88888
public static AccessSet get(final String _name)
        throws CacheReloadException
    {
        final Cache<String, AccessSet> cache = InfinispanCache.get().<String, AccessSet>getCache(AccessSet.NAMECACHE);
        if (!cache.containsKey(_name)) {
            AccessSet.getAccessSetFromDB(AccessSet.SQL_NAME, _name);
        }
        return cache.get(_name);
    }
1320626
public static Role get(final UUID _uuid)
        throws CacheReloadException
    {
        final Cache<UUID, Role> cache = InfinispanCache.get().<UUID, Role>getCache(Role.UUIDCACHE);
        if (!cache.containsKey(_uuid)) {
            Role.getRoleFromDB(Role.SQL_UUID, String.valueOf(_uuid));
        }
        return cache.get(_uuid);
    }
1137651
protected DbEntity cacheFilter(DbEntity persistentObject) {
    DbEntity cachedPersistentObject = dbEntityCache.get(persistentObject.getClass(), persistentObject.getId());
    if (cachedPersistentObject!=null) {
      return cachedPersistentObject;
    }
    else {
      return persistentObject;
    }

  }
121652
@SuppressWarnings("unchecked")
    static <S extends Storable> Factory<S> getFactory(Filter<S> filter) {
        if (filter == null) {
            throw new IllegalArgumentException();
        }
        synchronized (cCache) {
            Factory<S> factory = (Factory<S>) cCache.get(filter);
            if (factory != null) {
                return factory;
            }
            Class<Cursor<S>> clazz = generateClass(filter);
            factory = QuickConstructorGenerator.getInstance(clazz, Factory.class);
            cCache.put(filter, factory);
            return factory;
        }
    }
223150
public static function getFilter()
    {
        $mobileDeviceFilterClass = eZINI::instance()->variable( 'SiteAccessSettings', 'MobileDeviceFilterClass' );

        $mobileDeviceDetectFilter = class_exists( $mobileDeviceFilterClass) ? new $mobileDeviceFilterClass : null;

        if ( $mobileDeviceDetectFilter instanceof ezpMobileDeviceDetectFilterInterface )
            return $mobileDeviceDetectFilter;

        return null;
    }
267872
public static SQLTable get(final long _id)
        throws CacheReloadException
    {
        final Cache<Long, SQLTable> cache = InfinispanCache.get().<Long, SQLTable>getCache(SQLTable.IDCACHE);
        if (!cache.containsKey(_id)) {
            SQLTable.getSQLTableFromDB(SQLTable.SQL_ID, _id);
        }
        return cache.get(_id);
    }
1234023
public AbstractCollection getCollection()
        throws CacheReloadException
    {
        AbstractCollection ret = Form.get(this.collectionUUID);
        if (ret == null) {
            ret = Table.get(this.collectionUUID);
        }
        return ret;
    }
364225
public static Table get(final long _id)
        throws CacheReloadException
    {
        return AbstractUserInterfaceObject.<Table>get(_id, Table.class, CIAdminUserInterface.Table.getType());
    }
761830
public ExternalInvalidation filterExternalCacheFragment(String cacheName, ExternalInvalidation externalCacheFragment) {
		InvalidationTableList invalidationTableList = getInvalidationTableList(cacheName);
		try {
			invalidationTableList.readWriteLock.readLock().lock();
			return internalFilterExternalCacheFragment(cacheName, invalidationTableList, externalCacheFragment);
		} finally {
			invalidationTableList.readWriteLock.readLock().unlock();
		}
	}
396571
public Map<String, Attribute> getDependencies()
        throws CacheReloadException
    {
        if (this.dependencies == null) {
            this.dependencies = new TreeMap<>();
            // in case of a rate attribute the dependencies to the currencies
            // must be given
            if (getProperties().containsKey("CurrencyAttribute4Rate")) {
                this.dependencies.put("CurrencyAttribute4Rate",
                                getParent().getAttribute(getProperties().get("CurrencyAttribute4Rate")));
                this.dependencies.put("TargetCurrencyAttribute4Rate",
                                getParent().getAttribute(getProperties().get("TargetCurrencyAttribute4Rate")));
            }
        }
        return this.dependencies;
    }