class WFS_1_1_0_DataStore implements WFSDataStore {

    public FeatureReader<SimpleFeatureType, SimpleFeature> getFeatureReader(Query query,
            final Transaction transaction) throws IOException {

        if (Filter.EXCLUDE.equals(query.getFilter())) {
            return new EmptyFeatureReader<SimpleFeatureType, SimpleFeature>(getQueryType(query));
        }

        Filter[] filters = wfs.splitFilters(query.getFilter());
        Filter supportedFilter = filters[0];
        Filter postFilter = filters[1];
        if (LOGGER.isLoggable(Level.FINE)) {
            LOGGER.fine("Supported filter:  " + supportedFilter);
            LOGGER.fine("Unupported filter: " + postFilter);
        }
        query = createNewQuery(query, supportedFilter, postFilter);

        final CoordinateReferenceSystem queryCrs = query.getCoordinateSystem();

        WFSResponse response = executeGetFeatures(query, transaction, ResultType.RESULTS);

        Object result = WFSExtensions.process(this, response, mappedURIs);

        GetFeatureParser parser;
        if (result instanceof WFSException) {
            // try to recover from common server implementation errors
            throw (WFSException) result;
        } else if (result instanceof GetFeatureParser) {
            parser = (GetFeatureParser) result;
        } else {
            throw new IllegalStateException("Unknown response result for GetFeature: " + result);
        }

        final SimpleFeatureType contentType = getQueryType(query);

        FeatureReader<SimpleFeatureType, SimpleFeature> reader;
        reader = new WFSFeatureReader((GetFeatureParser) parser);

        if (!reader.hasNext()) {
            return new EmptyFeatureReader<SimpleFeatureType, SimpleFeature>(contentType);
        }

        final SimpleFeatureType readerType = reader.getFeatureType();

        CoordinateReferenceSystem readerCrs = readerType.getCoordinateReferenceSystem();
        String serverSrs = getServerSrs(query);
        if (queryCrs != null && serverSrs == null
                && !queryCrs.equals(readerCrs)) {
            try {
                reader = new ReprojectFeatureReader(reader, queryCrs);
            } catch (Exception e) {
                throw new DataSourceException(e);
            }
        }
        if(serverSrs != null) {
            try {
                reader = new ForceCoordinateSystemFeatureReader(reader, CRS.decode(serverSrs));
            } catch (Exception e) {
                throw new DataSourceException(e);
            }
        }
         

        if (Filter.INCLUDE != postFilter) {
            reader = new FilteringFeatureReader<SimpleFeatureType, SimpleFeature>(reader,
                    postFilter);
        }

        if (!contentType.equals(readerType)) {
            final boolean cloneContents = false;
            reader = new ReTypeFeatureReader(reader, contentType, cloneContents);
        }

        if (this.maxFeaturesHardLimit.intValue() > 0 || query.getMaxFeatures() != Integer.MAX_VALUE) {
            int maxFeatures = maxFeaturesHardLimit.intValue() > 0 ? Math.min(
                    maxFeaturesHardLimit.intValue(), query.getMaxFeatures()) : query
                    .getMaxFeatures();
            reader = new MaxFeatureReader<SimpleFeatureType, SimpleFeature>(reader, maxFeatures);
        }
        return reader;
    }

    public  WFS_1_1_0_DataStore(final WFSProtocol wfs);

}