gvSIG projects pool

package org.gvsig.report.lib.impl;

import java.util.Collection;

import java.util.Iterator;

import java.util.List;

import java.util.ListIterator;

import java.util.NoSuchElementException;

import org.gvsig.tools.util.UnmodifiableBasicList64;

/**

 *

 * @author jjdelcerro

 * @param <T>

 */

public class UnmodifiableBasicList64ToListAdapter<T> implements List<T> {

    private final UnmodifiableBasicList64<T> basiclist;

    public UnmodifiableBasicList64ToListAdapter(UnmodifiableBasicList64<T> basiclist) {

        this.basiclist = basiclist;

    }

    @Override

    public int size() {

        return (int) this.basiclist.size64();

    }

    @Override

    public boolean isEmpty() {

        return this.basiclist.isEmpty();

    }

    @Override

    public boolean contains(Object o) {

        return indexOf(o) >= 0;

    }

    @Override

    public Iterator<T> iterator() {

        return this.basiclist.iterator();

    }

    @Override

    public Object[] toArray() {

        int size = this.size();

        Object[] result = new Object[size];

        int i = 0;

        for (int j = 0; j < size; j++) {

            result[i++] = this.get(j);

        }

        return result;

    }

    @Override

    public <T> T[] toArray(T[] a) {

        int size = this.size();

        if (a.length < size)

            a = (T[])java.lang.reflect.Array.newInstance(

                a.getClass().getComponentType(), size

            );

        int i = 0;

        Object[] result = a;

        for (int j = 0; j < size; j++) {

            result[i++] = this.get(j);

        }

        if (a.length > size)

            a[size] = null;

        return a;

    }

    @Override

    public boolean add(T e) {

        throw new UnsupportedOperationException("Not supported yet."); 

    }

    @Override

    public boolean remove(Object o) {

        throw new UnsupportedOperationException("Not supported yet."); 

    }

    @Override

    public boolean containsAll(Collection<?> c) {

        for (Object e : c)

            if (!contains(e))

                return false;

        return true;

    }

    @Override

    public boolean addAll(Collection<? extends T> c) {

        throw new UnsupportedOperationException("Not supported yet."); 

    }

    @Override

    public boolean addAll(int index, Collection<? extends T> c) {

        throw new UnsupportedOperationException("Not supported yet."); 

    }

    @Override

    public boolean removeAll(Collection<?> c) {

        throw new UnsupportedOperationException("Not supported yet."); 

    }

    @Override

    public boolean retainAll(Collection<?> c) {

        throw new UnsupportedOperationException("Not supported yet."); 

    }

    @Override

    public void clear() {

        throw new UnsupportedOperationException("Not supported yet."); 

    }

    @Override

    public T get(int index) {

        return this.basiclist.get64(index);

    }

    @Override

    public T set(int index, T element) {

        throw new UnsupportedOperationException("Not supported yet."); 

    }

    @Override

    public void add(int index, T element) {

        throw new UnsupportedOperationException("Not supported yet."); 

    }

    @Override

    public T remove(int index) {

        throw new UnsupportedOperationException("Not supported yet."); 

    }

    @Override

    public int indexOf(Object o) {

        int size = (int) this.basiclist.size64();

        if (o == null) {

            for (int i = 0; i < size; i++)

                if (this.basiclist.get64(i)==null)

                    return i;

        } else {

            for (int i = 0; i < size; i++)

                if (o.equals(this.basiclist.get64(i)))

                    return i;

        }

        return -1;

    }

    @Override

    public int lastIndexOf(Object o) {

        int size = (int) this.basiclist.size64();

        if (o == null) {

            for (int i = size-1; i >= 0; i--)

                if (this.basiclist.get64(i)==null)

                    return i;

        } else {

            for (int i = size-1; i >= 0; i--)

                if (o.equals(this.basiclist.get64(i)))

                    return i;

        }

        return -1;

    }

    @Override

    public ListIterator<T> listIterator() {

        return new ListItr(0);

    }

    @Override

    public ListIterator<T> listIterator(int index) {

        if (index < 0 || index > size())

            throw new IndexOutOfBoundsException("Index: "+index);

        return new ListItr(index);

    }

    @Override

    public List<T> subList(int fromIndex, int toIndex) {

        throw new UnsupportedOperationException("Not supported yet."); 

    }

    private class Itr implements Iterator<T> {

        int cursor;       // index of next element to return

        Itr() {}

        @Override

        public boolean hasNext() {

            return cursor != size();

        }

        @Override

        public T next() {

            int i = cursor;

            if (i >= size())

                throw new NoSuchElementException();

            cursor = i + 1;

            return basiclist.get64(i);

        }

        @Override

        public void remove() {

            throw new UnsupportedOperationException("Not supported yet."); 

        }

    }

    private class ListItr extends Itr implements ListIterator<T> {

        ListItr(int index) {

            super();

            cursor = index;

        }

        @Override

        public boolean hasPrevious() {

            return cursor != 0;

        }

        @Override

        public int nextIndex() {

            return cursor;

        }

        @Override

        public int previousIndex() {

            return cursor - 1;

        }

        @Override

        public T previous() {

            int i = cursor - 1;

            if (i < 0)

                throw new NoSuchElementException();

            cursor = i;

            return  (T)basiclist.get64(i);

        }

        @Override

        public void set(T e) {

            throw new UnsupportedOperationException("Not supported yet."); 

        }

        @Override

        public void add(T e) {

            throw new UnsupportedOperationException("Not supported yet."); 

        }

    }

}

package org.gvsig.report.lib.impl;

import java.io.IOException;

import java.io.InputStream;

import java.net.URL;

import java.util.Objects;

import javax.json.Json;

import javax.json.JsonArray;

import javax.json.JsonArrayBuilder;

import javax.json.JsonObject;

import javax.json.JsonObjectBuilder;

import javax.json.JsonValue;

import org.apache.commons.lang3.StringUtils;

import org.apache.commons.lang3.builder.ToStringBuilder;

import org.apache.commons.lang3.builder.ToStringStyle;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.fmap.dal.feature.FeatureStore;

import org.gvsig.report.lib.api.Report;

import org.gvsig.report.lib.api.ReportConfig;

import org.gvsig.report.lib.api.ReportDataSet;

import org.gvsig.report.lib.api.ReportLocator;

import org.gvsig.report.lib.api.ReportServer;

import org.gvsig.tools.resourcesstorage.FilesResourcesStorage;

import org.gvsig.tools.resourcesstorage.ResourcesStorage;

/**

 *

 * @author jjdelcerro

 */

public class DefaultReportConfig implements ReportConfig {

    private String name;

    private String dataSetName;

    private String templateName;

    private String filterFieldPrefix;

    private ResourcesStorage reportResourcesStorage; // Persisten for FileResourcesStorage

    private ReportDataSet dataset; // not-persistent

    private ReportServer server;  // not-persistent

    private int layout;

    public DefaultReportConfig() {

    }

    @Override

    public void fromJSON(JsonObject json) {

        this.name = json.getString("name", null);

        this.dataSetName = json.getString("dataSetName", null);

        this.templateName = json.getString("templateName", null);

        this.filterFieldPrefix = json.getString("filterFieldPrefix", null);

        if (json.containsKey("FilesResourcesStorage") && !json.isNull("FilesResourcesStorage")) {

            JsonArray arrayJson = json.getJsonArray("FilesResourcesStorage");

            FilesResourcesStorage storage = null;

            for (JsonValue jsonValue : arrayJson) {

                if (storage == null) {

                    storage = new FilesResourcesStorage(jsonValue.toString());

                } else {

                    storage.getPaths().add(jsonValue.toString());

                }

            }

            this.reportResourcesStorage = storage;

        } else {

            this.reportResourcesStorage = null;

        }

        this.dataset = null;

        this.server = null;

    }

    @Override

    public JsonObject toJSON() {

        JsonObjectBuilder builder = Json.createObjectBuilder();

        builder.add("name", this.name);

        builder.add("dataSetName", this.getDataSetName());

        builder.add("templateName", this.templateName);

        if (this.filterFieldPrefix == null) {

            builder.addNull("filterFieldPrefix");

        } else {

            builder.add("filterFieldPrefix", this.filterFieldPrefix);

        }

        if (this.reportResourcesStorage instanceof FilesResourcesStorage) {

            // Esto lo usa el documento report del proyecto.

            FilesResourcesStorage storage = (FilesResourcesStorage) this.reportResourcesStorage;

            JsonArrayBuilder arrayBuilder = Json.createArrayBuilder();

            for (String path : storage.getPaths()) {

                arrayBuilder.add(path);

            }

            builder.add("FilesResourcesStorage", arrayBuilder);

        } else {

            builder.addNull("FilesResourcesStorage");

        }

        return builder.build();

    }

    @Override

    public String toString() {

        ToStringBuilder builder = new ToStringBuilder(this, ToStringStyle.SHORT_PREFIX_STYLE);

        builder.append("name", this.name);

        builder.append("dataSetName", this.dataSetName);

        builder.append("templateName", this.templateName);

        builder.append("filterFieldPrefix", this.filterFieldPrefix);

        if (this.reportResourcesStorage instanceof FilesResourcesStorage) {

            FilesResourcesStorage storage = (FilesResourcesStorage) this.reportResourcesStorage;

            builder.append("reportResourcesStorage", storage.getPaths().toArray());

        }

        return builder.toString();

    }

    @Override

    public String getName() {

        if (StringUtils.isBlank(name)) {

            if (StringUtils.isBlank(this.templateName)) {

                return this.getDataSetName();

            }

            return this.templateName;

        }

        return this.name;

    }

    @Override

    public void setName(String name) {

        this.name = name;

    }

    @Override

    public String getFilterFieldPrefix() {

        return this.filterFieldPrefix;

    }

    @Override

    public String getDataSetName() {

        if (StringUtils.isBlank(this.dataSetName)) {

            if (this.dataset == null) {

                return null;

            }

            return this.dataset.getName();

        }

        return this.dataSetName;

    }

    @Override

    public void setDataSetName(String name) {

        this.dataSetName = name;

    }

    @Override

    public String getReportTemplateName() {

        return this.templateName;

    }

    @Override

    public void setReportTemplate(String templateName) {

        this.templateName = templateName;

    }

    @Override

    public void setReportResourcesStorage(ResourcesStorage storage) {

        this.reportResourcesStorage = storage;

    }

    @Override

    public boolean hasDataSet() {

        if (this.dataset != null) {

            return true;

        }

        return !StringUtils.isBlank(this.dataSetName);

    }

    private ReportServer getServer() {

        if (this.server == null) {

            this.server = ReportLocator.getReportManager().getDefaultServer();

        }

        return this.server;

    }

    @Override

    public ReportDataSet getDataSet() {

        if (this.dataset == null) {

            if (StringUtils.isBlank(this.dataSetName)) {

                return null;

            }

            this.dataset = this.getServer().getConfig().getDataset(this.dataSetName);

            if (dataset == null) {

                DataManager dataManager = DALLocator.getDataManager();

                FeatureStore store = (FeatureStore) dataManager.getStoresRepository().getStore(this.dataSetName);

                if (store != null) {

                    this.dataset = ReportLocator.getReportManager().createDataSet(store);

                }

            }

        }

        return this.dataset;

    }

    @Override

    public void setDataSet(ReportDataSet dataset) {

        this.dataset = dataset;

    }

    @Override

    public ResourcesStorage getResources() {

        return this.getDataSet().getStore().getResourcesStorage();

    }

    @Override

    public ResourcesStorage.Resource getReportTemplateAsResource() {

        ResourcesStorage storage = this.getResources();

        ResourcesStorage.Resource resource = storage.getResource(templateName);

        return resource;

    }

    @Override

    public InputStream getReportTemplateAsStream() {

        URL url = null;

        try {

            ResourcesStorage.Resource resource = this.getReportTemplateAsResource();

            url = resource.getURL();

            return resource.asInputStream();

        } catch (IOException ex) {

            throw new RuntimeException("Can't access to report template '" + Objects.toString(url) + "'.", ex);

        }

    }

    @Override

    public URL getReportTemplateAsURL() {

        ResourcesStorage.Resource resource = this.getReportTemplateAsResource();

        URL url = resource.getURL();

        return url;

    }

    @Override

    public Report createReport() {

        Report r = new DefaultReport(this);

        return r;

    }

    @Override

    public int getLayoutManager() {

        return this.layout;

    }

    @Override

    public void setLayoutManager(int layout) {

        this.layout = layout;

    }

}

package org.gvsig.report.lib.impl;

import java.net.MalformedURLException;

import java.net.URL;

import java.util.ArrayList;

import java.util.HashSet;

import java.util.LinkedHashMap;

import java.util.List;

import java.util.Map;

import java.util.Set;

import java.util.concurrent.TimeUnit;

import org.apache.commons.lang3.StringUtils;

import org.apache.http.ExceptionLogger;

import org.apache.http.impl.nio.bootstrap.HttpServer;

import org.apache.http.impl.nio.bootstrap.ServerBootstrap;

import org.apache.http.impl.nio.reactor.IOReactorConfig;

import org.gvsig.report.lib.api.ReportDataSet;

import org.gvsig.report.lib.api.ReportManager;

import org.gvsig.report.lib.api.ReportServer;

import org.gvsig.report.lib.api.ReportServerConfig;

import org.gvsig.report.lib.api.ReportServices;

import org.gvsig.report.lib.api.ReportViewCapture;

import org.gvsig.report.lib.api.commands.Command;

import org.gvsig.report.lib.api.commands.CommandFactory;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

public class DefaultReportServer implements ReportServer {

    private static final Logger LOG = LoggerFactory.getLogger(DefaultReportServer.class);

    private static final List<HttpServer> servers = new ArrayList<>();

    static {

        Runtime.getRuntime().addShutdownHook(new Thread() {

            @Override

            public void run() {

                for (HttpServer server : servers) {

                    server.shutdown(5, TimeUnit.SECONDS);

                }

            }

        });

    }

    private HttpServer server;

    private final Set<LoggerListener> loglisteners;

    private Map<String, Command> commands;

    private final ReportServerConfig config;

    private final ReportManager manager;

    public DefaultReportServer(ReportManager manager, ReportServerConfig config) {

        this.manager = manager;

        this.config = config;

        this.loglisteners = new HashSet<>();

    }

    @Override

    public Map<String, Command> getCommands() {

        if (this.commands == null) {

            Map<String, Command>theCommands = new LinkedHashMap<>();

            for (CommandFactory factory : this.manager.getCommandFactories()) {

                theCommands.put(factory.getName(), factory.create(this));

            }

            this.commands = theCommands;

        }

        return this.commands;

    }

    public Command getCommand(String commandName) {

        if (commandName == null) {

            return null;

        }

        Command command = this.getCommands().get(commandName.toLowerCase());

        return command;

    }

    @Override

    public ReportServerConfig getConfig() {

        return this.config;

    }

    @Override

    public ReportServices getServices() {

        if (this.getConfig() == null) {

            return null;

        }

        return this.getConfig().getServices();

    }

    @Override

    public void addLogListener(LoggerListener logger) {

        this.loglisteners.add(logger);

    }

    @Override

    public void removeLogListener(LoggerListener logger) {

        this.loglisteners.remove(logger);

    }

    @Override

    public URL getURL(String path) {

        if( StringUtils.isBlank(path) ) {

            return null;

        }

        try {

            URL url = new URL("http", "localhost", this.config.getPort(),path);

            return url;

        } catch (MalformedURLException ex) {

            return null;

        }

    }

    @Override

    public String getHost() {

        String host = "http://localhost:" + this.config.getPort();

        return host;

    }

    @Override

    public void log(int level, String message) {

        switch (level) {

            default:

            case INFO:

                LOG.info(message);

                break;

            case WARN:

                LOG.warn(message);

                break;

            case DEBUG:

                LOG.debug(message);

                break;

        }

        for (LoggerListener logger : loglisteners) {

            logger.log(level, message);

        }

    }

    @Override

    public synchronized void start() {

        if (this.server != null) {

            this.stop();

        }

        final IOReactorConfig theConfig = IOReactorConfig.custom()

                .setSoTimeout(this.config.getTimeout())

                .setTcpNoDelay(true)

                .build();

        this.server = ServerBootstrap.bootstrap()

                .setListenerPort(this.config.getPort())

                .setServerInfo(this.config.getServerInfo())

                .setIOReactorConfig(theConfig)

                .setExceptionLogger(ExceptionLogger.STD_ERR)

                .registerHandler("*", new HttpHandler(this))

                .create();

        try {

            this.server.start();

            //this.server.awaitTermination(Long.MAX_VALUE, TimeUnit.DAYS);

            servers.add(this.server);

            log(INFO, "Server started.");

        } catch (Exception ex) {

        }

    }

    @Override

    public void reload() {

    }

    @Override

    public synchronized boolean isStarted() {

        return this.server != null;

    }

    @Override

    @SuppressWarnings("SleepWhileHoldingLock")

    public synchronized void stop() {

        if (this.server == null) {

            log(INFO, "Server already stoped.");

            return;

        }

        this.server.shutdown(5, TimeUnit.SECONDS);

        try {

            Thread.sleep(6000);

        } catch (InterruptedException ex) {

        }

        servers.remove(this.server);

        this.server = null;

        log(INFO, "Server stoped.");

    }

}

package org.gvsig.report.lib.impl;

import org.apache.commons.lang3.Range;

import org.gvsig.expressionevaluator.Interpreter;

import org.gvsig.expressionevaluator.spi.AbstractFunction;

import org.gvsig.expressionevaluator.spi.AbstractSymbolTable;

import static org.gvsig.report.lib.api.ReportManager.FUNCTION_REPORT_VALUE;

/**

 *

 * @author jjdelcerro

 */

public class ReportSymbolTable extends AbstractSymbolTable {

    private Object currentValue;

    public class ReportValueFunction extends AbstractFunction {

        public  ReportValueFunction() {

            super(

                    "Report", 

                    FUNCTION_REPORT_VALUE, 

                    Range.is(1), 

                    "Access to the fields of the current row of the report.",

                    FUNCTION_REPORT_VALUE+"({{field_name}})", 

                    new String[] {

                        "field_name - Name of the field in the current row to acess"

                    }, 

                    "Object", 

                    false

            );

        }

        @Override

        public Object call(Interpreter interpreter, Object[] args) throws Exception {

            return currentValue;

        }

    }

    public ReportSymbolTable() {

        this.addFunction(new ReportValueFunction());

    }

    public void setCurrentValue(Object value) {

        this.currentValue = value;

    }

}

/*

 * To change this license header, choose License Headers in Project Properties.

 * To change this template file, choose Tools | Templates

 * and open the template in the editor.

 */

package org.gvsig.report.lib.impl;

import java.beans.PropertyChangeListener;

import java.beans.PropertyChangeSupport;

import java.util.ArrayList;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.fmap.dal.feature.FeatureStore;

import org.gvsig.report.lib.api.ReportDataSet;

import org.gvsig.report.lib.api.ReportDataSets;

import org.gvsig.report.lib.api.ReportManager;

import org.gvsig.report.lib.api.ReportServices;

/**

 *

 * @author jjdelcerro

 */

public class DefaultReportDataSets 

        extends ArrayList<ReportDataSet> 

        implements ReportDataSets 

    {

    private final ReportServices services;

    private final ReportManager manager;

    private final PropertyChangeSupport propertyChangeSupport;

    public DefaultReportDataSets(ReportManager manager, ReportServices services) {

        this.services = services;

        this.manager = manager;

        this.propertyChangeSupport = new PropertyChangeSupport(this);

    }

    @Override

    public ReportDataSet get(String name) {

        for (ReportDataSet dataset : this) {

            if( dataset.getName().equalsIgnoreCase(name) ) {

                return dataset;

            }

        }

        return null;

    }    

    @Override

    public void add(String name, FeatureStore store) {

        if( !this.isValidName(name) ) {

            name = this.getValidName(name);

        }

        name = this.getUniqueName(name);

        ReportDataSet dataset = this.manager.createDataSet(services, name, store);

        this.add(dataset);

    }

    @Override

    public boolean add(ReportDataSet dataset) {

        String name = dataset.getName();

        if( !this.isValidName(name) ) {

            name = this.getValidName(name);

        }

        name = this.getUniqueName(name);

        dataset.setName(name);

        boolean x= super.add(dataset);

        this.propertyChangeSupport.firePropertyChange("add", null, null);

        return x;

    }

    @Override

    public void remove(String name) {

        ReportDataSet dataset = this.get(name);

        if( dataset == null ) {

            return;

        }

        this.remove(dataset);

        this.propertyChangeSupport.firePropertyChange("remove", null, null);

    }

    @Override

    public boolean contains(FeatureStore store) {

        for (ReportDataSet dataset : this) {

            if( dataset.hasThisStore(store) ) {

                return true;

            }

        }

        return false;

    }

    @Override

    public boolean contains(String name) {

        return this.get(name)!=null;

    }

    @Override

    public boolean isValidName(String name) {

        name = name.toLowerCase();

        if( !StringUtils.isAlpha(name.substring(0, 1)) ) {

            return false;

        }

        if( StringUtils.containsOnly("abcdefghijklmnopqrstuvwxyz0987654321_") ) {

            return true;

        }

        return false;

    }

    @Override

    public String getValidName(String name) {

        name = name.toLowerCase();

        name = StringUtils.normalizeSpace(name);

        name = StringUtils.replaceChars(name, '_', '_');

        name = StringUtils.replaceChars(name, ' ', '_');

        name = StringUtils.stripAccents(name);

        name = StringUtils.removeAll(name, "[^a-z0-9_]");

        return name;

    }

    @Override

    public String getUniqueName(String name) {

        if( !this.contains(name) ) {

            return name;

        }

        for (int i = 0; i < 1000; i++) {

            String s = name + "_" + i;

            if( !this.contains(s) ) {

                return s;

            }

        }

        return name + "_" + Long.toHexString(System.currentTimeMillis());

    }

    @Override

    public void addPropertyChangeListener(PropertyChangeListener listener) {

        this.propertyChangeSupport.addPropertyChangeListener(listener);

    }

    @Override

    public void removePropertyChangeListener(PropertyChangeListener listener) {

        this.propertyChangeSupport.removePropertyChangeListener(listener);

    }

}

package org.gvsig.report.lib.impl;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.expressionevaluator.Code;

import org.gvsig.expressionevaluator.Code.Callable;

import org.gvsig.expressionevaluator.Code.Constant;

import org.gvsig.expressionevaluator.Code.Identifier;

import org.gvsig.expressionevaluator.Codes;

import org.gvsig.expressionevaluator.Formatter;

import org.gvsig.fmap.dal.feature.FeatureAttributeDescriptor;

import org.gvsig.fmap.dal.feature.FeatureType;

import static org.gvsig.report.lib.api.ReportManager.FUNCTION_REPORT_VALUE;

import org.gvsig.timesupport.DataTypes;

/**

 *

 * @author jjdelcerro

 */

public class ReportExpressionCodeFormatter implements Formatter<Code> {

    public class IdentifierQuotesFormatter implements Formatter<Code> {

        @Override

        public boolean canApply(Code code) {

            if( code instanceof Identifier ) {

                return true;

            }

            return false;

        }

        @Override

        public String format(Code code) {

            // https://www.w3schools.com/tags/ref_urlencode.asp

            // Uff, es peor escaparlo, asi que de momento pondre corchetes.

            // return "%22"+((Identifier)code).name()+"%22";

            return "["+((Identifier)code).name()+"]";

        }

    }

    public class ReportValueFormatter implements Formatter<Code> {

        @Override

        public boolean canApply(Code value) {

            if (value instanceof Callable) {

                String name = ((Callable) value).name();

                if (StringUtils.equals(name, FUNCTION_REPORT_VALUE)) {

                    Codes args = ((Callable) value).parameters();

                    if (args.get(0) instanceof Constant

                            && ((Constant) (args.get(0))).value() instanceof String) {

                        return true;

                    }

                }

            }

            return false;

        }

        @Override

        public String format(Code value) {

            Codes args = ((Callable) value).parameters();

            String fieldName = ((Constant) (args.get(0))).value().toString();

            FeatureAttributeDescriptor attrdesc = featureType.getAttributeDescriptor(fieldName);

            switch(attrdesc.getType()) {

                case DataTypes.STRING:

                    return "'\"+$F{" + fieldName + "}+\"'";

                case DataTypes.INT:

                case DataTypes.LONG:

                case DataTypes.FLOAT:

                case DataTypes.DOUBLE:

                    return "\"+$F{" + fieldName + "}+\"";

                default: // ???

                    return "'\"+$F{" + fieldName + "}+\"'";

            }

        }

    }

    private final Formatter<Code>[] formatters;

    private final FeatureType featureType;

    public ReportExpressionCodeFormatter(FeatureType featureType) {

        this.featureType = featureType;

        this.formatters = new Formatter[]{

            new IdentifierQuotesFormatter(),

            new ReportValueFormatter()

        };

    }

    @Override

    public boolean canApply(Code code) {

        for (Formatter<Code> formatter : formatters) {

            if (formatter.canApply(code)) {

                return true;

            }

        }

        return false;

    }

    @Override

    public String format(Code code) {

        for (Formatter<Code> formatter : formatters) {

            if (formatter.canApply(code)) {

                return formatter.format(code);

            }

        }

        return code.toString();

    }

}

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright (C) 2007-2013 gvSIG Association.

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 3

 * of the License, or (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

 * MA  02110-1301, USA.

 *

 * For any additional information, do not hesitate to contact us

 * at info AT gvsig.com, or visit our website www.gvsig.com.

 */

package org.gvsig.report.lib.impl;

import java.util.Collection;

import java.util.LinkedHashMap;

import java.util.Map;

import javax.json.JsonObject;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.expressionevaluator.SymbolTable;

import org.gvsig.fmap.dal.feature.FeatureQuery;

import org.gvsig.fmap.dal.feature.FeatureStore;

import org.gvsig.report.lib.api.Report;

import org.gvsig.report.lib.api.ReportBuilder;

import org.gvsig.report.lib.api.ReportConfig;

import org.json.JSONObject;

import org.gvsig.report.lib.api.ReportDataSet;

import org.gvsig.report.lib.api.ReportManager;

import org.gvsig.report.lib.api.ReportServer;

import org.gvsig.report.lib.api.ReportServerConfig;

import org.gvsig.report.lib.api.ReportServices;

import org.gvsig.report.lib.api.ReportViewCapture;

import org.gvsig.report.lib.api.commands.CommandFactory;

import org.gvsig.report.lib.impl.commands.CaptureViewFactory;

import org.gvsig.report.lib.impl.commands.GetDatasetFactory;

import org.gvsig.report.lib.impl.commands.GetImageFactory;

import org.gvsig.report.lib.impl.commands.HelpFactory;

import org.gvsig.report.lib.impl.commands.ListDatasetsFactory;

import org.gvsig.report.lib.impl.commands.ListViewsFactory;

import org.gvsig.report.lib.impl.reportbuilder.DefaultReportBuilder;

import org.gvsig.tools.bookmarksandhistory.Bookmarks;

import org.gvsig.tools.bookmarksandhistory.History;

import org.gvsig.tools.bookmarksandhistory.impl.BaseBookmarks;

import org.gvsig.tools.bookmarksandhistory.impl.BaseHistory;

import org.gvsig.tools.resourcesstorage.ResourcesStorage;

/**

 *

 * @author jjdelcerro

 */

public class DefaultReportManager implements ReportManager {

    private ReportServer defaultServer = null;

    private final Map<String, CommandFactory> commandFactories;

    private Bookmarks<ReportBuilder> userDefinedReportBookmarks;

    private History<ReportBuilder> userDefinedReportHistory;

    @SuppressWarnings("OverridableMethodCallInConstructor")

    public DefaultReportManager() {

        this.commandFactories = new LinkedHashMap<>();

        this.registerCommandFactory(new CaptureViewFactory());

        this.registerCommandFactory(new GetDatasetFactory());

        this.registerCommandFactory(new HelpFactory());

        this.registerCommandFactory(new ListDatasetsFactory());

        this.registerCommandFactory(new ListViewsFactory());

        this.registerCommandFactory(new GetImageFactory());

        this.userDefinedReportBookmarks = new BaseBookmarks<>();

        this.userDefinedReportHistory = new BaseHistory<>(20);

    }

    @Override

    public Collection<CommandFactory> getCommandFactories() {

        return commandFactories.values();

    }

    @Override

    public void registerCommandFactory(CommandFactory factory) {

        this.commandFactories.put(factory.getName(), factory);

    }

    @Override

    public ReportServer getDefaultServer() {

        return this.defaultServer;

    }

    @Override

    public void setDefaultServer(ReportServer server) {

        this.defaultServer = server;

    }

    @Override

    public ReportServer createServer(ReportServerConfig config) {

        DefaultReportServer server = new DefaultReportServer(this, config);

        if (this.defaultServer == null) {

            this.defaultServer = server;

        }

        return server;

    }

    @Override

    public ReportDataSet createDataSet(

            ReportServices services,

            String name,

            FeatureStore store

    ) {

        return new DefaultReportDataSet(services, name, store);

    }

    @Override

    public ReportServerConfig createServerConfig(ReportServices services) {

        DefaultReportServerConfig config = new DefaultReportServerConfig(this, services);

        return config;

    }

    @Override

    public ReportServerConfig createServerConfig(ReportServices services, String jsonConfig) {

        DefaultReportServerConfig config = new DefaultReportServerConfig(this, services);

        if (!StringUtils.isEmpty(jsonConfig)) {

            config.fromJSON(new JSONObject(jsonConfig));

        }

        return config;

    }

    @Override

    public ReportViewCapture createViewCapture(ReportServerConfig config) {

        return new DefaultReportViewCapture(config);

    }

    @Override

    public SymbolTable createReportSymbolTable() {

        return new ReportSymbolTable();

    }

    @Override

    public ReportBuilder createReportBuilder() {

        ReportBuilder r = new DefaultReportBuilder();

        return r;

    }

    @Override

    public Bookmarks<ReportBuilder> getUserDefinedReportBookmarks() {

        return this.userDefinedReportBookmarks;

    }

    @Override

    public History<ReportBuilder> getUserDefinedReportHistory() {

        return this.userDefinedReportHistory;

    }

    @Override

    public void setUserDefinedReportHistory(History<ReportBuilder> history) {

        this.userDefinedReportHistory = history;

    }

    @Override

    public void setUserDefinedReportBookmarks(Bookmarks<ReportBuilder> userDefinedReportBookmarks) {

        this.userDefinedReportBookmarks = userDefinedReportBookmarks;

    }

    @Override

    public ReportDataSet createDataSet(FeatureStore store) {

        return new DefaultReportDataSet(this.defaultServer.getServices(), store.getName(), store);

    }

    @Override

    public ReportDataSet createDataSet(FeatureStore store, FeatureQuery query) {

        return new DefaultReportDataSet(this.defaultServer.getServices(), store.getName(), store, query);

    }

    @Override

    public Report createReport(ReportConfig config) {

        DefaultReport r = new DefaultReport(config);

        return r;

    }

    @Override

    public ReportConfig createReportConfig() {

        DefaultReportConfig r = new DefaultReportConfig();

        return r;

    }

}

package org.gvsig.report.lib.impl;

import java.io.IOException;

import java.net.URLDecoder;

import java.util.Locale;

import org.apache.commons.lang3.StringUtils;

import org.apache.http.HttpException;

import org.apache.http.HttpRequest;

import org.apache.http.HttpResponse;

import org.apache.http.HttpStatus;

import org.apache.http.MethodNotSupportedException;

import org.apache.http.entity.ByteArrayEntity;

import org.apache.http.entity.ContentType;

import org.apache.http.nio.entity.NStringEntity;

import org.apache.http.nio.protocol.BasicAsyncRequestConsumer;

import org.apache.http.nio.protocol.BasicAsyncResponseProducer;

import org.apache.http.nio.protocol.HttpAsyncExchange;

import org.apache.http.nio.protocol.HttpAsyncRequestConsumer;

import org.apache.http.nio.protocol.HttpAsyncRequestHandler;

import org.apache.http.protocol.HttpContext;

import static org.gvsig.report.lib.api.ReportServer.INFO;

import static org.gvsig.report.lib.api.ReportServer.WARN;

import org.gvsig.report.lib.api.commands.Command;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 *

 * @author jjdelcerro

 */

public class HttpHandler implements HttpAsyncRequestHandler<HttpRequest> {

    private static final Logger LOG = LoggerFactory.getLogger(HttpHandler.class);

    private final DefaultReportServer server;

    public HttpHandler(DefaultReportServer server) {

        super();

        this.server = server;

    }

    @Override

    public HttpAsyncRequestConsumer<HttpRequest> processRequest(

            final HttpRequest request,

            final HttpContext context) {

        // Buffer request content in memory for simplicity

        return new BasicAsyncRequestConsumer();

    }

    @Override

    public void handle(

            final HttpRequest request,

            final HttpAsyncExchange httpexchange,

            final HttpContext context) throws HttpException, IOException {

        final HttpResponse response = httpexchange.getResponse();

        handleInternal(request, response, context);

        httpexchange.submitResponse(new BasicAsyncResponseProducer(response));

    }

    private void handleInternal(

            final HttpRequest request,

            final HttpResponse response,

            final HttpContext context) throws HttpException, IOException {

        final String method = request.getRequestLine().getMethod().toUpperCase(Locale.ENGLISH);

        if (!method.equals("GET")) {

            this.server.log(WARN, "Method not supported, Only GET supported.");

            throw new MethodNotSupportedException(method + " method not supported");

        }

        final String target = request.getRequestLine().getUri();

        final String line = URLDecoder.decode(target, "UTF-8");

        final String[] args = StringUtils.split(line, '/');

        final int argc = args.length -1;

        Command command = this.server.getCommand(args[0]);

        if( command == null) {

            this.server.log(WARN, "Command '"+line+"' not found.");

            response.setStatusCode(HttpStatus.SC_NOT_FOUND);

            final NStringEntity entity = new NStringEntity(

                    "<html><body><h1>Command " + line

                    + " not found</h1></body></html>",

                    ContentType.create("text/html", "UTF-8"));

            response.setEntity(entity);

            return;

        }

        if( !command.getNumArgs().contains(argc) ) {

            this.server.log(WARN, "Command '"+line+"', invalid number of arguments.");

            response.setStatusCode(HttpStatus.SC_BAD_REQUEST);

            final NStringEntity entity = new NStringEntity(

                    "<html><body><h1>Number of arguments invalid in " + line

                    + "</h1></body></html>",

                    ContentType.create("text/html", "UTF-8"));

            response.setEntity(entity);

            return;

        }

        Object ret;

        try {

            ret = command.call(argc, args);

        } catch(Exception ex) {

            LOG.warn("Can't server command '"+line+"'.", ex);

            this.server.log(WARN, "Command '"+line+"', error "+ex.getMessage()+".");

            response.setStatusCode(HttpStatus.SC_INTERNAL_SERVER_ERROR);

            final NStringEntity entity = new NStringEntity(

                    "<html><body><h1>Error processing " + line

                    + "</h1><p>"+ex.toString()+"</p></body></html>",

                    ContentType.create("text/html", "UTF-8"));

            response.setEntity(entity);

            return;

        }

        if( ret == null ) {

            this.server.log(WARN, "Command '"+line+"' return null.");

            response.setStatusCode(HttpStatus.SC_INTERNAL_SERVER_ERROR);

            final NStringEntity entity = new NStringEntity(

                    "<html><body><h1>Process " + line

                    + " return null</h1></body></html>",

                    ContentType.create("text/html", "UTF-8"));

            response.setEntity(entity);

            return;

        }

        if( ret instanceof byte[] ) {

            response.setStatusCode(HttpStatus.SC_OK);

            final ByteArrayEntity entity = new ByteArrayEntity(

                    (byte[]) ret,

                    ContentType.create(command.getMimeType(), "UTF-8"));

            response.setEntity(entity);

            this.server.log(INFO, "Command '"+line+"' ok.");

            return;

        }

        response.setStatusCode(HttpStatus.SC_OK);

        final NStringEntity entity = new NStringEntity(

                ret.toString(),

                ContentType.create(command.getMimeType(), "UTF-8"));

        response.setEntity(entity);

        this.server.log(INFO, "Command '"+line+"' ok.");

    }

}

package org.gvsig.report.lib.impl;

import java.util.ArrayList;

import java.util.Iterator;

import java.util.List;

import java.util.NoSuchElementException;

import org.apache.commons.collections.CollectionUtils;

import org.apache.commons.lang3.mutable.MutableInt;

import org.gvsig.fmap.dal.exception.DataException;

import org.gvsig.fmap.dal.feature.Feature;

import org.gvsig.fmap.dal.feature.FeatureReference;

import org.gvsig.fmap.dal.feature.FeatureSet;

import org.gvsig.report.lib.api.ReportDataSet.SelectionOfFeatures;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.exception.BaseException;

import org.gvsig.tools.task.SimpleTaskStatus;

import org.gvsig.tools.task.TaskStatusManager;

import org.gvsig.tools.visitor.VisitCanceledException;

import org.gvsig.tools.visitor.Visitable;

import org.gvsig.tools.visitor.Visitor;

/**

 *

 * @author jjdelcerro

 */

public class DefaultSelectionOfFeatures

        implements SelectionOfFeatures {

    private class FeatureReferenceIteratorToFeatureIteratorAdapter implements Iterator<Feature> {

        private final Iterator<FeatureReference> iterator;

        private int count;

        public FeatureReferenceIteratorToFeatureIteratorAdapter(Iterator<FeatureReference> iterator) {

            this.iterator = iterator;

            this.count = 0;

        }

        @Override

        public boolean hasNext() {

            int limit = dataSet.getLimit();

            if (limit < this.count) {

                return false;

            }

            return this.iterator.hasNext();

        }

        @Override

        public Feature next() {

            int limit = dataSet.getLimit();

            if (limit < this.count) {

                throw new NoSuchElementException();

            }

            this.count++;

            FeatureReference fr = this.iterator.next();

            try {

                return fr.getFeature();

            } catch (DataException ex) {

                throw new RuntimeException(ex);

            }

        }

    }

    private List<FeatureReference> references;

    private List<String> referenceCodes;

    private final DefaultReportDataSet dataSet;

    public DefaultSelectionOfFeatures(DefaultReportDataSet dataSet) {

        this.dataSet = dataSet;

        this.references = new ArrayList<>();

        this.referenceCodes = null;

    }

    private void resolveReferenceCodes() {

        if (this.referenceCodes == null) {

            return;

        }

        for (String referenceCode : this.referenceCodes) {

            FeatureReference reference = this.dataSet.getStore().getFeatureReference(referenceCode);

            this.references.add(reference);

        }

        this.referenceCodes = null;

    }

    @Override

    public Feature get64(long pos) {

        if (this.referenceCodes != null) {

            this.resolveReferenceCodes();

        }

        int limit = this.dataSet.getLimit();

        if (limit > 0 && pos > limit) {

            throw new ArrayIndexOutOfBoundsException((int) pos);

        }

        try {

            FeatureReference reference = this.references.get((int) pos);

            return reference.getFeature();

        } catch (DataException ex) {

            throw new RuntimeException("Can't retrieve feature from reference.", ex);

        }

    }

    public FeatureReference getReference(int pos) {

        if (this.referenceCodes != null) {

            this.resolveReferenceCodes();

        }

        FeatureReference reference = this.references.get(pos);

        return reference;

    }

    @Override

    public long size64() {

        int limit = this.dataSet.getLimit();

        int size;

        if (this.referenceCodes == null) {

            size = this.references.size();

        } else {

            size = this.referenceCodes.size();

        }

        if (limit > 0 && limit < size) {

            size = limit;

        }

        return size;

    }