Application: gvSIG desktop » gvSIG raster

/* gvSIG. Geographic Information System of the Valencian Government

 *

 * Copyright (C) 2007-2008 Infrastructures and Transports Department

 * of the Valencian Government (CIT)

 *

 * 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 2

 * 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.

 *

 */

package org.gvsig.raster.impl;

import java.awt.geom.AffineTransform;

import java.awt.geom.Dimension2D;

import java.lang.reflect.Constructor;

import java.lang.reflect.InvocationTargetException;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.Set;

import org.cresques.cts.IProjection;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataStoreParameters;

import org.gvsig.fmap.dal.coverage.BufferFactory;

import org.gvsig.fmap.dal.coverage.RasterLibrary;

import org.gvsig.fmap.dal.coverage.RasterManager;

import org.gvsig.fmap.dal.coverage.RasterService;

import org.gvsig.fmap.dal.coverage.dataset.Buffer;

import org.gvsig.fmap.dal.coverage.datastruct.DataStructFactory;

import org.gvsig.fmap.dal.coverage.datastruct.Extent;

import org.gvsig.fmap.dal.coverage.datastruct.GridExtent;

import org.gvsig.fmap.dal.coverage.datastruct.Params;

import org.gvsig.fmap.dal.coverage.datastruct.RasterLegend;

import org.gvsig.fmap.dal.coverage.datastruct.ViewPortData;

import org.gvsig.fmap.dal.coverage.exception.NotSupportedExtensionException;

import org.gvsig.fmap.dal.coverage.exception.ProcessInterruptedException;

import org.gvsig.fmap.dal.coverage.exception.RasterBufferInvalidException;

import org.gvsig.fmap.dal.coverage.exception.RasterDriverException;

import org.gvsig.fmap.dal.coverage.exception.RasterLegendIONotFound;

import org.gvsig.fmap.dal.coverage.grid.AbstractROI;

import org.gvsig.fmap.dal.coverage.grid.Grid;

import org.gvsig.fmap.dal.coverage.grid.RasterFilterList;

import org.gvsig.fmap.dal.coverage.grid.render.ImageDrawer;

import org.gvsig.fmap.dal.coverage.process.TaskEventManager;

import org.gvsig.fmap.dal.coverage.process.overview.OverviewBuilder;

import org.gvsig.fmap.dal.coverage.process.vector.Vectorization;

import org.gvsig.fmap.dal.coverage.store.DataServerWriter;

import org.gvsig.fmap.dal.coverage.store.RasterDataStore;

import org.gvsig.fmap.dal.coverage.store.RasterQuery;

import org.gvsig.fmap.dal.coverage.store.RasterWriter;

import org.gvsig.fmap.dal.coverage.store.props.ColorInterpretation;

import org.gvsig.fmap.dal.coverage.store.props.Statistics;

import org.gvsig.fmap.dal.coverage.util.CRSUtils;

import org.gvsig.fmap.dal.coverage.util.ColorConversion;

import org.gvsig.fmap.dal.coverage.util.FileUtils;

import org.gvsig.fmap.dal.coverage.util.Historical;

import org.gvsig.fmap.dal.coverage.util.MathUtils;

import org.gvsig.fmap.dal.coverage.util.ProviderServices;

import org.gvsig.fmap.dal.coverage.util.RasterUtils;

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

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

import org.gvsig.fmap.dal.raster.spi.CoverageStoreProvider;

import org.gvsig.fmap.dal.spi.DataManagerProviderServices;

import org.gvsig.raster.impl.buffer.DefaultDataServerWriter;

import org.gvsig.raster.impl.buffer.DefaultRasterQuery;

import org.gvsig.raster.impl.buffer.RasterBuffer;

import org.gvsig.raster.impl.buffer.RasterMemoryBuffer;

import org.gvsig.raster.impl.buffer.cache.RasterCache;

import org.gvsig.raster.impl.buffer.cache.RasterReadOnlyBuffer;

import org.gvsig.raster.impl.datastruct.DefaultDataStructFactory;

import org.gvsig.raster.impl.datastruct.DefaultViewPortData;

import org.gvsig.raster.impl.datastruct.legend.GimpGradients;

import org.gvsig.raster.impl.datastruct.legend.GimpPalettes;

import org.gvsig.raster.impl.datastruct.legend.LegendgvSIG;

import org.gvsig.raster.impl.datastruct.legend.RasterLegendIO;

import org.gvsig.raster.impl.grid.GridImpl;

import org.gvsig.raster.impl.grid.filter.DefaultRasterFilterList;

import org.gvsig.raster.impl.grid.render.ImageDrawerImpl;

import org.gvsig.raster.impl.grid.roi.ROIStatistic;

import org.gvsig.raster.impl.process.DefaultTaskEventManager;

import org.gvsig.raster.impl.process.RasterTask;

import org.gvsig.raster.impl.process.RasterTaskQueue;

import org.gvsig.raster.impl.process.vector.PotraceVectorization;

import org.gvsig.raster.impl.provider.DefaultRasterProvider;

import org.gvsig.raster.impl.provider.RasterProvider;

import org.gvsig.raster.impl.store.AbstractRasterDataParameters;

import org.gvsig.raster.impl.store.DefaultRasterStore;

import org.gvsig.raster.impl.store.ParamsImpl;

import org.gvsig.raster.impl.store.QueryableRaster;

import org.gvsig.raster.impl.store.properties.DataStoreColorInterpretation;

import org.gvsig.raster.impl.store.writer.DefaultRasterWriter;

import org.gvsig.raster.util.DefaultCRSUtils;

import org.gvsig.raster.util.DefaultColorConversion;

import org.gvsig.raster.util.DefaultFileUtils;

import org.gvsig.raster.util.DefaultHistorical;

import org.gvsig.raster.util.DefaultMathUtils;

import org.gvsig.raster.util.DefaultProviderServices;

import org.gvsig.raster.util.DefaultRasterUtils;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.extensionpoint.ExtensionPoint;

import org.gvsig.tools.extensionpoint.ExtensionPointManager;

import org.gvsig.tools.service.ServiceException;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 * Default {@link RasterManager} implementation.

 * 

 * @author gvSIG Team

 * @version $Id$

 */

public class DefaultRasterManager implements RasterManager {

        private static DefaultRasterManager internalInstance  = new DefaultRasterManager();

        private static final Logger         logger            = LoggerFactory.getLogger(DefaultRasterManager.class);

        private CRSUtils                    crs               = null;

        private FileUtils                   file              = null;

        private MathUtils                   math              = null;

        private RasterUtils                 util              = null;

        private ProviderServices            pInfo             = null;

        private DefaultColorConversion      colorConversion   = null;

        private DataStructFactory           dataStructFactory = null;

        private static Class<?>             tileclass         = null;

        private static ArrayList<Class<?>>  tiledProviders    = new ArrayList<Class<?>>(); 

        private static HashMap<String, ArrayList<Class<?>>>

                                        formatsRegistry   = new HashMap<String, ArrayList<Class<?>>>();

        public static HashMap<String, OverviewBuilder>

                                                                            overviewBuilderRegistry   = new HashMap<String, OverviewBuilder>();

        /**

         * Gets an instance of this object for internal use.

         * @return DefaultRasterManager

         */

        public static DefaultRasterManager getInstance() {

                return internalInstance;

        }

        public DataStructFactory getDataStructFactory() {

                if(dataStructFactory == null)

                        dataStructFactory = new DefaultDataStructFactory();

                return dataStructFactory;

        }

        public ProviderServices getProviderServices() {

                if(pInfo == null)

                        pInfo = new DefaultProviderServices();

                return pInfo;

        }

        public CRSUtils getCRSUtils() {

                if(crs == null)

                        crs = new DefaultCRSUtils();

                return crs;

        }

        public FileUtils getFileUtils() {

                if(file == null)

                        file = new DefaultFileUtils();

                return file;

        }

        public RasterUtils getRasterUtils() {

                if(util == null)

                        util = new DefaultRasterUtils();

                return util;

        }

        public MathUtils getMathUtils() {

                if(math == null)

                        math = new DefaultMathUtils();

                return math;

        }

    public RasterService getRasterService()

        throws ServiceException {

        RasterService fc = new DefaultRasterService(this);

        return fc;

    }

        public String[] getLegendFormats() {

                return RasterLegendIO.formats;

        }

        public RasterLegend getRasterLegendIO(String formatName) throws RasterLegendIONotFound {

                if (formatName.equals(RasterLegendIO.formats[0]))

                        return new LegendgvSIG();

                if (formatName.equals(RasterLegendIO.formats[1]))

                        return new GimpGradients();

                if (formatName.equals(RasterLegendIO.formats[2]))

                        return new GimpPalettes();

                // Incluir mas formatos de la misma manera

                throw new RasterLegendIONotFound();

        }

        public DataServerWriter createDataServerWriter() {

                return new DefaultDataServerWriter();

        }

        public RasterDataStore open(CoverageStoreProvider prov, DataStoreParameters params) throws NotSupportedExtensionException, RasterDriverException {

                if(prov instanceof RasterProvider) {

                        DefaultRasterStore store = new DefaultRasterStore();

                        store.setProvider((RasterProvider)prov);

                        try {

                                store.intializePhase1(null, params);

                        } catch (InitializeException e) {

                                throw new RasterDriverException(e.getMessage());

                        }

                        return store;

                }

                return null;

        }

        public RasterDataStore open(DataStoreParameters params) throws NotSupportedExtensionException, RasterDriverException {

                if(params == null || !(params instanceof AbstractRasterDataParameters))

                        return null;

                DefaultRasterStore dSet = new DefaultRasterStore();

                DataManagerProviderServices dataManager = (DataManagerProviderServices)DALLocator.getDataManager();

                try {

                        DefaultRasterProvider provider = (DefaultRasterProvider)dataManager.createProvider(dSet, (AbstractRasterDataParameters)params);

                        dSet.setProvider(provider);

                } catch (InitializeException e) {

                        throw new RasterDriverException("Error initializing provider", e);

                } catch (ProviderNotRegisteredException e) {

                        throw new RasterDriverException("Provider not register error", e);

                }

                return dSet;

        }

        public RasterDataStore open(Object datasetOpenParam) throws NotSupportedExtensionException, RasterDriverException {

                DefaultRasterStore dSet = new DefaultRasterStore();

                if (datasetOpenParam instanceof String) {

                        DefaultRasterProvider provider = DefaultRasterProvider.singleDatasetInstance(dSet, (String)datasetOpenParam);

                        dSet.setProvider(provider);

                        return dSet;

                }

                /*if (datasetOpenParam instanceof String[]) {

                        String[] param = (String[]) datasetOpenParam;

                        try {

                                for (int dataset = 0; dataset < param.length; dataset++) {

                                        dSet.addDataStore(DefaultRasterProvider.singleDatasetInstance(dSet, param[dataset]) );

                                }

                        } catch (OperationNotSupportedException e) {

                                return open(param[0]);

                        }

                        return dSet;

                } 

                if (datasetOpenParam instanceof Buffer[]) {

                        Buffer[] param = (Buffer[]) datasetOpenParam;

                        for (int dataset = 0; dataset < param.length; dataset++) {

                                dSet.addDataStore(DefaultRasterProvider.singleDatasetInstance(param[dataset]));

                        }

                        return dSet;

                }

                if(datasetOpenParam instanceof String[][]) {

                        String[][] param = (String[][])datasetOpenParam;

                        DefaultMultiRasterStore[][] mosaic = new DefaultMultiRasterStore[param.length][param[0].length];

                        for (int i = 0; i < param.length; i++)

                                for (int j = 0; j < param[i].length; j++)

                                        mosaic[i][j] = (DefaultMultiRasterStore)open(param[i][j]);

                        DefaultMosaicRasterStore cd;

                        try {

                                cd = new DefaultMosaicRasterStore(mosaic);

                        } catch (MosaicNotValidException e) {

                                return null;

                        }

                        return cd;

                }*/

                return null;

        }

        public RasterQuery createQuery() {

                return new DefaultRasterQuery();

        }

        public Buffer createBuffer(int dataType, int width, int height, int bandNr, boolean malloc) {

                //Opci?n de cachear siempre activada (Solo DEBUG)

                if(RasterBuffer.forceToLoadInCache)

                        return new RasterCache(dataType, width, height, bandNr);

                if(RasterBuffer.forceToLoadInReadOnlyCache){

                return new RasterReadOnlyBuffer(dataType, width, height, bandNr);

                }

                if(RasterBuffer.cacheOn){

                        long size = (long)((long)getRasterUtils().getBytesFromRasterBufType(dataType) * (long)width * (long)height * (long)bandNr) / 1024L;

                        long ms1 = RasterLibrary.cacheSize * 1024L;

                        if(size <= ms1)

                                return new RasterMemoryBuffer(dataType, width, height, bandNr, malloc);

                        else

                                return new RasterCache(dataType, width, height, bandNr);

                }else

                        return new RasterMemoryBuffer(dataType, width, height, bandNr, malloc);

        }

        public Buffer createReadOnlyBuffer(int dataType, int width, int height, int bandNr) {

                return new RasterReadOnlyBuffer(dataType, width, height, bandNr);

        }

        public Buffer createMemoryBuffer(int dataType, int width, int height, int bandNr, boolean malloc) {

                return new RasterMemoryBuffer(dataType, width, height, bandNr, malloc);

        }

        @SuppressWarnings("unchecked")

        public RasterWriter createWriter(String fName) throws NotSupportedExtensionException, RasterDriverException {

                String ext = getFileUtils().getExtensionFromFileName(fName);

                DefaultRasterWriter grw = null;

                ExtensionPointManager extensionPoints = ToolsLocator.getExtensionPointManager();

                ExtensionPoint point = extensionPoints.get("RasterWriter");

//                ExtensionPoint extensionPoint = ExtensionPoint.getExtensionPoint("RasterWriter");

                if (!point.has(ext))

                        return grw;

                Class clase = point.get(ext).getExtension();

                Class[] args = { String.class };

                try {

                        Constructor hazNuevo = clase.getConstructor(args);

                        Object[] args2 = { fName };

                        grw = (DefaultRasterWriter) hazNuevo.newInstance(args2);

                } catch (SecurityException e) {

                        throw new RasterDriverException("Error SecurityException in open", e);

                } catch (NoSuchMethodException e) {

                        throw new RasterDriverException("Error NoSuchMethodException in open", e);

                } catch (IllegalArgumentException e) {

                        throw new RasterDriverException("Error IllegalArgumentException in open", e);

                } catch (InstantiationException e) {

                        throw new RasterDriverException("Error InstantiationException in open", e);

                } catch (IllegalAccessException e) {

                        throw new RasterDriverException("Error IllegalAccessException in open", e);

                } catch (InvocationTargetException e) {

                        throw new NotSupportedExtensionException("Error in open", e);

                }

                return grw;

        }

        public RasterWriter createWriter(DataServerWriter dataWriter,

                                                                                                 String outFileName,

                                                                                                 int nBands,

                                                                                                 AffineTransform at,

                                                                                                 int outSizeX,

                                                                                                 int outSizeY,

                                                                                                 int dataType,

                                                                                                 Params params,

                                                                                                 IProjection proj) throws NotSupportedExtensionException, RasterDriverException {

                return createWriter(dataWriter, outFileName, nBands, at, outSizeX, outSizeY, dataType, params, proj, true);

        }

        @SuppressWarnings("unchecked")

        public RasterWriter createWriter(DataServerWriter dataWriter,

                                                                                                 String outFileName,

                                                                                                 int nBands,

                                                                                                 AffineTransform at,

                                                                                                 int outSizeX,

                                                                                                 int outSizeY,

                                                                                                 int dataType,

                                                                                                 Params params,

                                                                                                 IProjection proj,

                                                                                                 boolean geo) throws NotSupportedExtensionException, RasterDriverException {

                String ext = outFileName.toLowerCase().substring(outFileName.lastIndexOf('.') + 1);

                DefaultRasterWriter grw = null;

                ExtensionPointManager extensionPoints = ToolsLocator.getExtensionPointManager();

                ExtensionPoint point = extensionPoints.get("RasterWriter");

                if (!point.has(ext))

                        return grw;

                Class clase = point.get(ext).getExtension();

                Class[] args = { DataServerWriter.class, String.class, Integer.class, AffineTransform.class, Integer.class, Integer.class, Integer.class, Params.class, IProjection.class, Boolean.class };

                try {

                        Constructor hazNuevo = clase.getConstructor(args);

                        Object [] args2 = {dataWriter, outFileName, new Integer(nBands), at,

                                                                new Integer(outSizeX), new Integer(outSizeY), new Integer(dataType),

                                                                params, proj, new Boolean(geo)};

                        grw = (DefaultRasterWriter) hazNuevo.newInstance(args2);

                } catch (SecurityException e) {

                        throw new RasterDriverException("Error SecurityException in open", e);

                } catch (NoSuchMethodException e) {

                        throw new RasterDriverException("Error NoSuchMethodException in open", e);

                } catch (IllegalArgumentException e) {

                        throw new RasterDriverException("Error IllegalArgumentException in open", e);

                } catch (InstantiationException e) {

                        throw new RasterDriverException("Error InstantiationException in open", e);

                } catch (IllegalAccessException e) {

                        throw new RasterDriverException("Error IllegalAccessException in open", e);

                } catch (InvocationTargetException e) {

                        throw new NotSupportedExtensionException("Error in open. Problemas con las librer?as nativas.", e);

                }

                return grw;

        }

        public Params createWriterParams(String fileName) {

                try {

                        return createWriter(fileName).getParams();

                } catch (NotSupportedExtensionException e) {

                        return null;

                } catch (RasterDriverException e) {

                        return null;

                }

        }

        /**

         * Gets an object which vectorize a raster

         * @param dataStore

         * @return

         * @throws RasterDriverException

         * @throws ProcessInterruptedException

         *         When the object Vectorization is built the raster data buffer is loaded. 

         *         This operation can be interrupted

         */

        public Vectorization getVectorizeObject(QueryableRaster queryable) throws RasterDriverException, ProcessInterruptedException {

                return new PotraceVectorization(queryable);

        }

        public OverviewBuilder getOverviewBuilder(String id) {

                return overviewBuilderRegistry.get(id);

        }

        public boolean isOverviewBuilderSupported() {

                return overviewBuilderRegistry.size() > 0;

        }

        public Set<String> getOverviewBuilderKeyList() {

                return overviewBuilderRegistry.keySet();

        }

        public ColorInterpretation createColorInterpretation(String[] colorInterp) {

                return new DataStoreColorInterpretation(colorInterp);

        }

        public Grid createGrid(RasterDataStore datasource, int[] bands, GridExtent windowExtent) throws RasterBufferInvalidException {

                return new GridImpl(datasource, bands, windowExtent);

        }

        public Grid createGrid(RasterDataStore datasource, int[] bands) throws RasterBufferInvalidException {

                return new GridImpl(datasource, bands);

        }

        public Grid createGrid(RasterDataStore datasource) throws RasterBufferInvalidException {

                return new GridImpl(datasource);

        }

        public Grid createGrid(GridExtent layerExtent,

                        GridExtent windowExtent,

                        int dataType,

                        int[] bands) throws RasterBufferInvalidException {

                return new GridImpl(layerExtent, windowExtent, dataType, bands);

        }

        public Grid createGrid(Buffer buf, RasterDataStore datasource, boolean notInterp) {

                return new GridImpl(buf, datasource, notInterp);

        }

    public Historical createHistoricalService() {

            return new DefaultHistorical();

    }

    public ViewPortData createViewPortData(IProjection proj, Extent extent, Dimension2D size) {

            return new DefaultViewPortData(proj, extent, size);

    }

    public ViewPortData createViewPortData() {

            return new DefaultViewPortData();

    }

    public ColorConversion getColorConversion() {

            if(colorConversion == null)

                    colorConversion = new DefaultColorConversion();

            return colorConversion;

    }

        public Statistics createROIStatistics(AbstractROI roi) {

                return new ROIStatistic(roi);

        }

        public RasterFilterList createEmptyFilterList(int type) {

                DefaultRasterFilterList fl = new DefaultRasterFilterList();

                fl.setInitDataType(type);

                return fl;

        }

        public TaskEventManager getRasterTask() {

                return DefaultTaskEventManager.get();

        }

        public TaskEventManager createRasterTask(Object process) {

                RasterTask task = RasterTaskQueue.getRasterTask(Thread.currentThread().getId() + "");

                if(task != null) {

                        DefaultTaskEventManager man = new DefaultTaskEventManager();

                        man.setTask(task);

                        return man;

                }

                DefaultTaskEventManager man = new DefaultTaskEventManager(process);

                return man;

        }

        /**

         * Builds a new parameter object. These parameters represents the fieds of a filter

         * panel.

         * @param id

         * @param value

         * @param type

         * @param list

         * @return

         */

        public Params createParams(String id, Object value, int type, String[] list) {

                ParamsImpl params = new ParamsImpl();

                params.setParam(id, 

                                value, 

                                type, 

                                list);

                return params;

        }

        public void registerFileProvidersTiled(Class<?> provider) {

                if(!tiledProviders.contains(provider))

                        tiledProviders.add(provider);

        }

        public void registerTileProviderFormats(Class<?> c) {

                if(tileclass == null) {

                        if(RasterProvider.class.isAssignableFrom(c)) {

                                ArrayList<?> pList = getTiledProvidersInstance();

                                for (int i = 0; i < pList.size(); i++) {

                                        String[] fList = ((RasterProvider)pList.get(i)).getFormatList();

                                        for (int j = 0; j < fList.length; j++) {

                                                String value = fList[j];

                                                addFormat(value, c);

                                        }

                                }

                        }

                        tileclass = c;

                }

        }

        @SuppressWarnings("unchecked")

        private ArrayList<?> getTiledProvidersInstance() {

                ArrayList list = new ArrayList();

                for (int i = 0; i < tiledProviders.size(); i++) {

                        Class<?> provider = tiledProviders.get(i);

                        try {

                                Constructor c = provider.getConstructor();

                                list.add(c.newInstance());

                        } catch (SecurityException e) {

                                logger.info("Error SecurityException in open", e);

                        } catch (NoSuchMethodException e) {

                                logger.info("Error NoSuchMethodException in open", e);

                        } catch (IllegalArgumentException e) {

                                logger.info("Error IllegalArgumentException in open", e);

                        } catch (InstantiationException e) {

                                logger.info("Error InstantiationException in open", e);

                        } catch (IllegalAccessException e) {

                                logger.info("Error IllegalAccessException in open", e);

                        } catch (InvocationTargetException e) {

                                logger.info("Error in open. Problemas con las librer?as nativas.", e);

                        }

                }

                return list;

        }

        public void addFormat(String ext, Class<?> c) {

                ArrayList<Class<?>> list = formatsRegistry.get(ext);

                if(list == null) {

                        list = new ArrayList<Class<?>>();

                        list.add(c);

                        formatsRegistry.put(ext, list);

                } else {

                        if(!list.contains(c))

                                list.add(c);

                }

        }

        public boolean isExtensionSupported(String ext, Class<?> c) {

                String extension = getFileUtils().getExtensionFromFileName(ext);

                ArrayList<Class<?>> list = formatsRegistry.get(extension);

                if(list == null) {

                        return false;

                } else {

                        for (int i = 0; i < list.size(); i++) {

                                if(c == list.get(i))

                                        return true;

                        }

                }

                return false;

        }

        public boolean isExtensionSupported(String ext) {

                String extension = getFileUtils().getExtensionFromFileName(ext);

                ArrayList<Class<?>> list = formatsRegistry.get(extension);

                if(list == null) {

                        return false;

                } 

                return true;

        }

        public String[] getReadOnlyFormatList() {

                return formatsRegistry.keySet().toArray(new String[0]);

        }

        public ImageDrawer createImageDrawerService() {

                return new ImageDrawerImpl();

        }

        public BufferFactory getBufferFactory() {

                return new BufferFactoryImpl();

        }

}