HibCatalogImpl.java

/* Copyright (c) 2001 - 2008 TOPP - www.openplans.org. All rights reserved.
 * This code is licensed under the GPL 2.0 license, available at the root
 * application directory.
 */

package org.geoserver.catalog.hibernate;

import java.io.Serializable;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.net.URI;
import java.rmi.server.UID;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.logging.Level;
import java.util.logging.Logger;

import org.apache.commons.collections.MultiHashMap;
import org.apache.commons.io.FilenameUtils;
import org.geoserver.catalog.Catalog;
import org.geoserver.catalog.CatalogInfo;
import org.geoserver.catalog.CatalogVisitor;
import org.geoserver.catalog.CoverageDimensionInfo;
import org.geoserver.catalog.CoverageInfo;
import org.geoserver.catalog.CoverageStoreInfo;
import org.geoserver.catalog.DataStoreInfo;
import org.geoserver.catalog.FeatureTypeInfo;
import org.geoserver.catalog.LayerGroupInfo;
import org.geoserver.catalog.LayerInfo;
import org.geoserver.catalog.MapInfo;
import org.geoserver.catalog.MetadataMap;
import org.geoserver.catalog.NamespaceInfo;
import org.geoserver.catalog.ResourceInfo;
import org.geoserver.catalog.ResourcePool;
import org.geoserver.catalog.StoreInfo;
import org.geoserver.catalog.StyleInfo;
import org.geoserver.catalog.WorkspaceInfo;
import org.geoserver.catalog.event.CatalogAddEvent;
import org.geoserver.catalog.event.CatalogEvent;
import org.geoserver.catalog.event.CatalogListener;
import org.geoserver.catalog.event.CatalogModifyEvent;
import org.geoserver.catalog.event.CatalogPostModifyEvent;
import org.geoserver.catalog.event.CatalogRemoveEvent;
import org.geoserver.catalog.event.impl.CatalogAddEventImpl;
import org.geoserver.catalog.event.impl.CatalogModifyEventImpl;
import org.geoserver.catalog.event.impl.CatalogPostModifyEventImpl;
import org.geoserver.catalog.event.impl.CatalogRemoveEventImpl;
import org.geoserver.catalog.impl.CoverageDimensionImpl;
import org.geoserver.catalog.impl.CoverageInfoImpl;
import org.geoserver.catalog.impl.FeatureTypeInfoImpl;
import org.geoserver.catalog.impl.LayerGroupInfoImpl;
import org.geoserver.catalog.impl.ModificationProxy;
import org.geoserver.catalog.impl.NamespaceInfoImpl;
import org.geoserver.catalog.impl.ResolvingProxy;
import org.geoserver.catalog.impl.ResourceInfoImpl;
import org.geoserver.catalog.impl.StoreInfoImpl;
import org.geoserver.catalog.impl.StyleInfoImpl;
import org.geoserver.catalog.impl.WorkspaceInfoImpl;
import org.geoserver.hibernate.dao.CatalogDAO;
import org.geoserver.ows.util.ClassProperties;
import org.geoserver.ows.util.OwsUtils;
import org.geoserver.platform.GeoServerResourceLoader;
import org.geotools.util.logging.Logging;
import org.opengis.feature.type.Name;
import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.web.context.WebApplicationContext;
import org.vfny.geoserver.global.GeoserverDataDirectory;

/**
 * A {@link Catalog} implementation based on Hibernate
 * 
 * @author ETj
 */

public class HibCatalogImpl implements Catalog, Serializable, ApplicationContextAware {

    private final static Logger LOGGER = Logging.getLogger(HibCatalogImpl.class);

    /**
     *
     */
    private CatalogDAO catalogDAO;

    /**
     * Flag indicating whether events are fired on commit or as they happen
     */
    private boolean fireEventsOnCommit = false;

    /**
     * listeners
     */
    private List<CatalogListener> listeners = new ArrayList<CatalogListener>();

    /**
     * events
     * 
     * TODO: ETJ rework this: what do we need the key for in this map?
     */
    private Map<HibCatalogImpl, CatalogEvent> events = Collections.synchronizedMap(new MultiHashMap());

    /**
     * resources
     */
    private ResourcePool resourcePool;

    // really needed??
    private GeoServerResourceLoader resourceLoader;

    private HibCatalogImpl() {
        super();
        resourcePool = new ResourcePool(this);

        listeners.add(new HibCatalogUpdater());        
    }

    public String getId() {
        return "catalog";
    }

    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        GeoserverDataDirectory.init((WebApplicationContext) applicationContext);
    }

    /**
     * @see Catalog#getFactory()
     * @see HibernateCatalogFactory
     */
    public HibCatalogFactoryImpl getFactory() {
        return new HibCatalogFactoryImpl(this);
    }

    /**
     * Sets whether to fire events on commits, intended to be used by unit tests only?
     */
    void setFireEventsOnCommit(boolean fireEventsOnCommit) {
        this.fireEventsOnCommit = fireEventsOnCommit;
    }

    boolean isFireEventsOnCommit() {
        return fireEventsOnCommit;
    }

    // Store methods
    public void add(StoreInfo store) {

        if (LOGGER.isLoggable(Level.INFO))
            LOGGER.info("Adding store " + store.getClass().getSimpleName() + " " + store.getName());

        if (store.getWorkspace() == null) {
            store.setWorkspace(catalogDAO.getDefaultWorkspace());
        }

        validate(store, true);
        resolve(store);
        StoreInfo unwrapped = ModificationProxy.unwrap(store);
        unwrapped.setWorkspace(ModificationProxy.unwrap(unwrapped.getWorkspace()));
        catalogDAO.save(unwrapped);
        ((StoreInfoImpl) store).setId(store.getId()); // make the ModificationProxy aware of the id
        if (LOGGER.isLoggable(Level.INFO))
            LOGGER.info("Added store " + store.getClass().getSimpleName() + "[id: " + store.getId()
                    + " name:" + store.getName() + "]");
        added(store);
    }

    void validate(StoreInfo store, boolean isNew) {
        if (isNull(store.getName())) {
            throw new IllegalArgumentException("Store name must not be null");
        }
        if (store.getWorkspace() == null) {
            throw new IllegalArgumentException("Store must be part of a workspace");
        }

        WorkspaceInfo workspace = store.getWorkspace();
        StoreInfo existing = getStoreByName(workspace, store.getName(), StoreInfo.class);
        if (existing != null && !existing.getId().equals(store.getId())) {
            String msg = "Store '" + store.getName() + "' already exists in workspace '"
                    + workspace.getName() + "'";
            throw new IllegalArgumentException(msg);
        }
    }

    public void remove(StoreInfo store) {
        if (!getResourcesByStore(store, ResourceInfo.class).isEmpty()) {
            throw new IllegalArgumentException("Unable to delete non-empty store.");
        }
        store = unwrap(store);
        catalogDAO.delete(store);
        removed(store);
    }

    public void save(StoreInfo store) {
        validate(store, false);

        if (store.getId() == null) {
            // add it instead of saving
            add(store);
            return;
        }

        saved(store);
    }

    private Class<? extends StoreInfo> mapStoreClass(StoreInfo store) {
        if (store instanceof DataStoreInfo)
            return DataStoreInfo.class;
        else if (store instanceof CoverageStoreInfo)
            return CoverageStoreInfo.class;
        else
            return StoreInfo.class; // should not happen
    }

    private Class<? extends ResourceInfo> mapResourceClass(ResourceInfo resource) {
        if (resource instanceof FeatureTypeInfo)
            return FeatureTypeInfo.class;
        else if (resource instanceof CoverageInfo)
            return CoverageInfo.class;
        else
            return ResourceInfo.class; // should not happen
    }

    protected <T> T createProxy(T obj, Class<T> clazz) {
        return obj;
    }

    protected <T> List<T> createProxyList(List<T> list, Class<T> clazz) {
        return list;
    }

    public <T extends StoreInfo> T getStore(String id, Class<T> clazz) {
        StoreInfo store = catalogDAO.getStore(id, clazz);
        if (store == null) {
            return null;
        } else {
            resolve(store);
            return createProxy((T) store, (Class<T>) mapStoreClass(store));
        }
    }

    public <T extends StoreInfo> T getStoreByName(String name, Class<T> clazz) {
        T freestore = getStoreByName((WorkspaceInfo) null, name, clazz);
        if (freestore != null) {
            return freestore;
        }

        // look for secondary match
        List matches = catalogDAO.getStoresByName(name, clazz);
        if (matches.size() == 1) {
            StoreInfo store = (StoreInfo) matches.get(0);
            resolve(store);
            return createProxy((T) store, (Class<T>) mapStoreClass(store));
        }

        return null;
    }

    public <T extends StoreInfo> T getStoreByName(WorkspaceInfo workspace, String name,
            Class<T> clazz) {

        if (workspace == null) {
            workspace = catalogDAO.getDefaultWorkspace();
        } else {
            workspace = ModificationProxy.unwrap(workspace);
        }

        StoreInfo store = catalogDAO.getStoreByName(workspace, name, clazz);
        if (store == null) {
            return null;
        } else {
            resolve(store);
            return createProxy((T) store, (Class<T>) mapStoreClass(store));
        }

    }

    public <T extends StoreInfo> T getStoreByName(String workspaceName, String name, Class<T> clazz) {
        return getStoreByName(workspaceName != null ? getWorkspaceByName(workspaceName) : null,
                name, clazz);
    }

    public <T extends StoreInfo> List<T> getStoresByWorkspace(String workspaceName, Class<T> clazz) {

        WorkspaceInfo workspace = null;
        if (workspaceName != null) {
            workspace = getWorkspaceByName(workspaceName);
            if (workspace == null) {
                return Collections.EMPTY_LIST;
            }
        }

        return getStoresByWorkspace(workspace, clazz);
    }

    public <T extends StoreInfo> List<T> getStoresByWorkspace(WorkspaceInfo workspace,
            Class<T> clazz) {

        if (workspace == null) {
            workspace = catalogDAO.getDefaultWorkspace();
        } else
            workspace = ModificationProxy.unwrap(workspace);

        List matches = catalogDAO.getStoresByWorkspace(workspace, clazz);

        for (StoreInfo store : (List<StoreInfo>) matches) {
            resolve(store);
        }

        Class proxyclass = matches.isEmpty() ? clazz : mapStoreClass((StoreInfo) matches.get(0));
        return createProxyList(matches, proxyclass);
    }

    public List getStores(Class clazz) {
        List stores = catalogDAO.getStores(clazz);
        for (StoreInfo store : (List<StoreInfo>) stores) {
            resolve(store);
        }
        Class proxyclass = stores.isEmpty() ? clazz : mapStoreClass((StoreInfo) stores.get(0));
        return createProxyList(stores, proxyclass);
    }

    public DataStoreInfo getDataStore(String id) {
        return (DataStoreInfo) getStore(id, DataStoreInfo.class);
    }

    public DataStoreInfo getDataStoreByName(String name) {
        return (DataStoreInfo) getStoreByName(name, DataStoreInfo.class);
    }

    public DataStoreInfo getDataStoreByName(String workspaceName, String name) {
        return (DataStoreInfo) getStoreByName(workspaceName, name, DataStoreInfo.class);
    }

    public DataStoreInfo getDataStoreByName(WorkspaceInfo workspace, String name) {
        return (DataStoreInfo) getStoreByName(workspace, name, DataStoreInfo.class);
    }

    public List<DataStoreInfo> getDataStoresByWorkspace(String workspaceName) {
        return getStoresByWorkspace(workspaceName, DataStoreInfo.class);
    }

    public List<DataStoreInfo> getDataStoresByWorkspace(WorkspaceInfo workspace) {
        return getStoresByWorkspace(workspace, DataStoreInfo.class);
    }

    public List<DataStoreInfo> getDataStores() {
        return getStores(DataStoreInfo.class);
    }

    public CoverageStoreInfo getCoverageStore(String id) {
        return (CoverageStoreInfo) getStore(id, CoverageStoreInfo.class);
    }

    public CoverageStoreInfo getCoverageStoreByName(String name) {
        return (CoverageStoreInfo) getStoreByName(name, CoverageStoreInfo.class);
    }

    public CoverageStoreInfo getCoverageStoreByName(String workspaceName, String name) {
        return getStoreByName(workspaceName, name, CoverageStoreInfo.class);
    }

    public CoverageStoreInfo getCoverageStoreByName(WorkspaceInfo workspace, String name) {
        return getStoreByName(workspace, name, CoverageStoreInfo.class);
    }

    public List<CoverageStoreInfo> getCoverageStoresByWorkspace(String workspaceName) {
        return getStoresByWorkspace(workspaceName, CoverageStoreInfo.class);
    }

    public List<CoverageStoreInfo> getCoverageStoresByWorkspace(WorkspaceInfo workspace) {
        return getStoresByWorkspace(workspace, CoverageStoreInfo.class);
    }

    public List<CoverageStoreInfo> getCoverageStores() {
        return getStores(CoverageStoreInfo.class);
    }

    // Resource methods
    public void add(ResourceInfo resource) {
        if (resource.getNamespace() == null) {
            // default to default namespace
            resource.setNamespace(catalogDAO.getDefaultNamespace());
        }

        validate(resource, true);
        resolve(resource);
        // resources.put(resource.getClass(), resource);
        ResourceInfo unwrappedResource = ModificationProxy.unwrap(resource);
        unwrappedResource.setNamespace(ModificationProxy.unwrap(unwrappedResource.getNamespace()));
        StoreInfo unwrappedStore = ModificationProxy.unwrap(resource.getStore());
        unwrappedResource.setStore(unwrappedStore);
        unwrappedStore.setWorkspace(ModificationProxy.unwrap(unwrappedStore.getWorkspace()));

        fixNativeName(unwrappedResource);

        catalogDAO.save(unwrappedResource);
        added(resource);
    }

    void validate(ResourceInfo resource, boolean isNew) {
        if (isNull(resource.getName())) {
            throw new NullPointerException("Resource name must not be null");
        }
        if (resource.getStore() == null) {
            throw new IllegalArgumentException("Resource must be part of a store");
        }
        if (resource.getNamespace() == null) {
            throw new IllegalArgumentException("Resource must be part of a namespace");
        }

        StoreInfo store = resource.getStore();
        ResourceInfo existing = getResourceByStore(store, resource.getName(), ResourceInfo.class);
        if (existing != null && !existing.getId().equals(resource.getId())) {
            String msg = "Resource named '" + resource.getName() + "' already exists in store: '"
                    + store.getName() + "'";
            throw new IllegalArgumentException(msg);
        }

        NamespaceInfo namespace = resource.getNamespace();
        existing = getResourceByName(namespace, resource.getName(), ResourceInfo.class);
        if (existing != null && !existing.getId().equals(resource.getId())) {
            String msg = "Resource named '" + resource.getName()
                    + "' already exists in namespace: '" + namespace.getPrefix() + "'";
            throw new IllegalArgumentException(msg);
        }

    }

    public void remove(ResourceInfo resource) {
        // ensure no references to the resource
        if (!getLayers(resource).isEmpty()) {
            throw new IllegalArgumentException("Unable to delete resource referenced by layer");
        }
        resource = unwrap(resource);
        catalogDAO.delete(resource);
        removed(resource);
    }

    public void save(ResourceInfo resource) {
        validate(resource, false);
        saved(resource);
    }

    public <T extends ResourceInfo> T getResource(String id, Class<T> clazz) {
        ResourceInfo resource = catalogDAO.getResource(id, clazz);
        if (resource == null)
            return null;
        else {
            resolve(resource);
            return createProxy((T) resource, clazz);
        }

    }

    public <T extends ResourceInfo> T getResourceByName(String ns, String name, Class<T> clazz) {

        NamespaceInfo namespace = null;
        if ("".equals(ns)) {
            ns = null;
        }
        if (ns == null) {
            // if namespace was null, try the default namespace
            if (getDefaultNamespace() != null) {
                namespace = getDefaultNamespace();
            }
        } else {
            namespace = getNamespaceByPrefix(ns);
            if (namespace == null) {
                namespace = getNamespaceByURI(ns);
            }
        }

        if (namespace != null) {
            ResourceInfo resource = catalogDAO.getResourceByName(namespace.getName(), name, clazz);
            if (resource != null) {
                resolve(resource);
            // return ModificationProxy.create( (T) resource, clazz );
                return createProxy((T) resource, (Class<T>) mapResourceClass(resource));
            }
        }

        // List l = lookup(clazz, resources);
        // if ( namespace != null ) {
        // for (Iterator i = l.iterator(); i.hasNext();) {
        // ResourceInfo resource = (ResourceInfo) i.next();
        // if (name.equals(resource.getName())) {
        // NamespaceInfo namespace1 = resource.getNamespace();
        // if (namespace1 != null && namespace1.equals( namespace )) {
        // return ModificationProxy.create( (T) resource, clazz );
        // }
        // }
        // }
        // }

        if (ns == null) {
            // no namespace was specified, so do an exhaustive lookup
            List<ResourceInfo> matches = (List<ResourceInfo>) catalogDAO.getResourcesByName(name,
                    clazz);
            // List matches = new ArrayList();
            // for (Iterator i = l.iterator(); i.hasNext();) {
            // ResourceInfo resource = (ResourceInfo) i.next();
            // if (name.equals(resource.getName())) {
            // matches.add( resource );
            // }
            // }

            if (matches.size() == 1) {
                ResourceInfo ret = matches.get(0);
                resolve(ret);
                return createProxy((T) ret, (Class<T>) mapResourceClass(ret));
                // return ModificationProxy.create( (T) matches.get( 0 ), clazz );
            }
        }
        return null;
    }

    public <T extends ResourceInfo> T getResourceByName(NamespaceInfo ns, String name,
            Class<T> clazz) {
        return getResourceByName(ns != null ? ns.getPrefix() : null, name, clazz);
    }

    public <T extends ResourceInfo> T getResourceByName(Name name, Class<T> clazz) {
        return getResourceByName(name.getNamespaceURI(), name.getLocalPart(), clazz);
    }

    public <T extends ResourceInfo> T getResourceByName(String name, Class<T> clazz) {
        ResourceInfo resource;

        // check is the name is a fully qualified one
        int colon = name.indexOf(':');
        if (colon != -1) {
            String ns = name.substring(0, colon);
            String localName = name.substring(colon + 1);
            return getResourceByName(ns, localName, clazz);
        } else {
            return getResourceByName((String) null, name, clazz);
        }
    }

    public List getResources(Class clazz) {
        // return ModificationProxy.createList( lookup(clazz,resources), clazz );
        // return ModificationProxy.createList( catalogDAO.getResources(clazz), clazz );
        List<ResourceInfo> list = catalogDAO.getResources(clazz);
        for (ResourceInfo resourceInfo : list) {
            resolve(resourceInfo);
        }

        return createProxyList(list, clazz);
    }

    public List getResourcesByNamespace(NamespaceInfo namespace, Class clazz) {
        // List all = lookup(clazz, resources);
        // List matches = new ArrayList();

        if (namespace == null) {
            namespace = getDefaultNamespace();
        }

        // for (Iterator r = all.iterator(); r.hasNext();) {
        // ResourceInfo resource = (ResourceInfo) r.next();
        // if (namespace != null ) {
        // if (namespace.equals(resource.getNamespace())) {
        // matches.add( resource );
        // }
        // }
        // else if ( resource.getNamespace() == null ) {
        // matches.add(resource);
        // }
        // }

        List<ResourceInfo> matches = catalogDAO.getResourcesByNamespace(namespace, clazz);
        for (ResourceInfo resource : matches) {
            resolve(resource);
        }
        Class proxyclass = matches.isEmpty() ? clazz : mapResourceClass((ResourceInfo) matches
                .get(0));
        // return ModificationProxy.createList( matches, clazz );
        return createProxyList(matches, proxyclass);
    }

    public <T extends ResourceInfo> List<T> getResourcesByNamespace(String namespace, Class<T> clazz) {
        if (namespace == null) {
            return getResourcesByNamespace((NamespaceInfo) null, clazz);
        }

        NamespaceInfo ns = getNamespaceByPrefix(namespace);
        if (ns == null) {
            ns = getNamespaceByURI(namespace);
        }
        if (ns == null) {
            return Collections.EMPTY_LIST;
        }

        return getResourcesByNamespace(ns, clazz);
    }

    public <T extends ResourceInfo> T getResourceByStore(StoreInfo store, String name,
            Class<T> clazz) {

        store = ModificationProxy.unwrap(store);
        ResourceInfo resource = catalogDAO.getResourceByStore(store, name, clazz);
        if (resource == null)
            return null;
        else {
            resolve(resource);
            return createProxy((T) resource, (Class<T>) mapResourceClass(resource));
        }

        // List all = lookup(clazz,resources);
        // for (Iterator r = all.iterator(); r.hasNext(); ) {
        // ResourceInfo resource = (ResourceInfo) r.next();
        // if ( name.equals( resource.getName() ) && store.equals( resource.getStore() ) ) {
        // return ModificationProxy.create((T)resource, clazz);
        // }
        //
        // }
        //
        // return null;
    }

    public <T extends ResourceInfo> List<T> getResourcesByStore(StoreInfo store, Class<T> clazz) {
        store = ModificationProxy.unwrap(store);
        // refine clazz type searching
        Class typedClazz = clazz;
        if (clazz.equals(ResourceInfo.class)) {
            if (store instanceof DataStoreInfo) {
                typedClazz = FeatureTypeInfo.class;
            } else if (store instanceof CoverageStoreInfo) {
                typedClazz = CoverageInfo.class;
            } else
                throw new IllegalArgumentException("Unknown store type "
                        + store.getClass().getName());
        }
        List<T> resources = catalogDAO.getResourcesByStore(store, (Class<T>) typedClazz);
        for (ResourceInfo resource : resources) {
            resolve(resource);
        }
        Class proxyclazz = resources.isEmpty() ? typedClazz : mapResourceClass(resources.get(0));
        // return ModificationProxy.createList( resources, proxyclazz );
        return createProxyList(resources, proxyclazz);

        // List all = lookup(clazz,resources);
        // List matches = new ArrayList();
        //
        // for (Iterator r = all.iterator(); r.hasNext();) {
        // ResourceInfo resource = (ResourceInfo) r.next();
        // if (store.equals(resource.getStore())) {
        // matches.add(resource);
        // }
        // }
        //
        // return ModificationProxy.createList( matches, clazz );
    }

    public FeatureTypeInfo getFeatureType(String id) {
        return (FeatureTypeInfo) getResource(id, FeatureTypeInfo.class);
    }

    public FeatureTypeInfo getFeatureTypeByName(String ns, String name) {
        return (FeatureTypeInfo) getResourceByName(ns, name, FeatureTypeInfo.class);
    }

    public FeatureTypeInfo getFeatureTypeByName(NamespaceInfo ns, String name) {
        return getResourceByName(ns, name, FeatureTypeInfo.class);
    }

    public FeatureTypeInfo getFeatureTypeByName(Name name) {
        return getResourceByName(name, FeatureTypeInfo.class);
    }

    public FeatureTypeInfo getFeatureTypeByName(String name) {
        return (FeatureTypeInfo) getResourceByName(name, FeatureTypeInfo.class);
    }

    public List<FeatureTypeInfo> getFeatureTypes() {
        return getResources(FeatureTypeInfo.class);
    }

    public List getFeatureTypesByNamespace(NamespaceInfo namespace) {
        return getResourcesByNamespace(namespace, FeatureTypeInfo.class);
    }

    public FeatureTypeInfo getFeatureTypeByStore(DataStoreInfo dataStore, String name) {
        return getFeatureTypeByDataStore(dataStore, name);
    }

    public FeatureTypeInfo getFeatureTypeByDataStore(DataStoreInfo dataStore, String name) {
        return getResourceByStore(dataStore, name, FeatureTypeInfo.class);
    }

    public List<FeatureTypeInfo> getFeatureTypesByStore(DataStoreInfo store) {
        return getFeatureTypesByDataStore(store);
    }

    public List<FeatureTypeInfo> getFeatureTypesByDataStore(DataStoreInfo store) {
        return getResourcesByStore(store, FeatureTypeInfo.class);
    }

    public CoverageInfo getCoverage(String id) {
        return (CoverageInfo) getResource(id, CoverageInfo.class);
    }

    public CoverageInfo getCoverageByName(String ns, String name) {
        return (CoverageInfo) getResourceByName(ns, name, CoverageInfo.class);
    }

    public CoverageInfo getCoverageByName(NamespaceInfo ns, String name) {
        return (CoverageInfo) getResourceByName(ns, name, CoverageInfo.class);
    }

    public CoverageInfo getCoverageByName(Name name) {
        return getResourceByName(name, CoverageInfo.class);
    }

    public CoverageInfo getCoverageByName(String name) {
        return (CoverageInfo) getResourceByName(name, CoverageInfo.class);
    }

    public List<CoverageInfo> getCoverages() {
        return getResources(CoverageInfo.class);
    }

    public List getCoveragesByNamespace(NamespaceInfo namespace) {
        return getResourcesByNamespace(namespace, CoverageInfo.class);
    }

    public List<CoverageInfo> getCoveragesByStore(CoverageStoreInfo store) {
        return getResourcesByStore(store, CoverageInfo.class);
    }

    public CoverageInfo getCoverageByCoverageStore(CoverageStoreInfo coverageStore, String name) {
        return getResourceByStore(coverageStore, name, CoverageInfo.class);
    }

    public List<CoverageInfo> getCoveragesByCoverageStore(CoverageStoreInfo store) {
        return getResourcesByStore(store, CoverageInfo.class);
    }

    // Layer methods
    public void add(LayerInfo layer) {
        validate(layer, true);
        resolve(layer);

        if (layer.getType() == null) {
            if (layer.getResource() instanceof FeatureTypeInfo) {
                layer.setType(LayerInfo.Type.VECTOR);
            } else if (layer.getResource() instanceof CoverageInfo) {
                layer.setType(LayerInfo.Type.RASTER);
            } else {
                String msg = "Layer type not set and can't be derived from resource";
                throw new IllegalArgumentException(msg);
            }
        }

        // layers.add(layer);
        LayerInfo unwrapped = unwrap(layer);
        ResourceInfo resource = unwrapped.getResource();
        if (resource != null) {
            resource = unwrap(resource);
            unwrapped.setResource(resource);
        }

        LOGGER.warning("SAVING LAYER id:" + unwrapped.getId() + " name:" + unwrapped.getName());
        LOGGER.warning("  layer.resource " + unwrapped.getResource().getClass().getSimpleName()
                + "[" + "id:" + unwrapped.getResource().getId() + " name:"
                + unwrapped.getResource().getName() + "]");

        if (unwrapped.getDefaultStyle() != null)
            LOGGER.warning("  layer.style " + "[" + "id:" + unwrapped.getDefaultStyle().getId()
                    + " name:" + unwrapped.getDefaultStyle().getName() + "]");

        fixNativeName(resource);

        catalogDAO.save(unwrapped);
        added(layer);
    }

    /**
     * <B>FIXME This is a workaround to fill in nativeName in coverages.</B> Please investigate why
     * its value is not assigned.
     * 
     * @deprecated this is a workaround
     */
    private void fixNativeName(ResourceInfo resource) {
        if (resource != null && resource.getNativeName() == null) {
            if (resource instanceof CoverageInfo) {
                LOGGER.warning("FIXME Coverage is missing nativeName (" + "id:" + resource.getId()
                        + " name:" + resource.getName() + ")");
                String storeurl = ((CoverageInfo) resource).getStore().getURL();
                String name = FilenameUtils.getBaseName(storeurl);
                resource.setNativeName(name);
                LOGGER.warning("FIXME setting coverage nativeName to " + name);
            }
        }
    }

    void validate(LayerInfo layer, boolean isNew) {
        if (isNull(layer.getName())) {
            throw new NullPointerException("Layer name must not be null");
        }

        LayerInfo existing = getLayerByName(layer.getName());
        if (existing != null && !existing.getId().equals(layer.getId())) {
            // JD: since layers are not qualified by anything (yet), check
            // namespace of the resource, if they are different then allow the
            // layer to be added
            if (existing.getResource().getNamespace().equals(layer.getName())) {
                throw new IllegalArgumentException("Layer named '" + layer.getName()
                        + "' already exists.");
            }
        }

        if (layer.getResource() == null) {
            throw new NullPointerException("Layer resource must not be null");
        }
        // (JD): not sure if default style should be mandatory
        // if ( layer.getDefaultStyle() == null ){
        // throw new NullPointerException( "Layer default style must not be null" );
        // }
    }

    public void remove(LayerInfo layer) {
        // ensure no references to the layer
        for (LayerGroupInfo lg : catalogDAO.getLayerGroups()) {
            if (lg.getLayers().contains(layer)) {
                String msg = "Unable to delete layer referenced by layer group '" + lg.getName()
                        + "'";
                throw new IllegalArgumentException(msg);
            }
        }
        // layers.remove(unwrap(layer));
        catalogDAO.delete(layer);
        removed(layer);
    }

    public void save(LayerInfo layer) {
        validate(layer, false);
        saved(layer);
    }

    public LayerInfo getLayer(String id) {
        LayerInfo layer = catalogDAO.getLayer(id);
        if (layer == null)
            return null;
        else {
            resolve(layer);
            return createProxy(layer, LayerInfo.class);
        }

    }

    public LayerInfo getLayerByName(Name name) {
        if (name.getNamespaceURI() != null) {
            NamespaceInfo ns = getNamespaceByURI(name.getNamespaceURI());
            if (ns != null) {
                return getLayerByName(ns.getPrefix() + ":" + name.getLocalPart());
            }
        }

        return getLayerByName(name.getLocalPart());
    }

    public LayerInfo getLayerByName(String name) {
        String prefix = null;
        String resource = null;

        LayerInfo layer;

        int colon = name.indexOf(':');
        if (colon != -1) {
            // search by resource name
            prefix = name.substring(0, colon);
            resource = name.substring(colon + 1);

            // todo: check original code: it compared vs the resource name

            layer = catalogDAO.getLayerByName(prefix, resource);

        } else {
            // search by layer name
            layer = catalogDAO.getLayerByName(name);

        }

        if (layer != null) {
            resolve(layer);
            return createProxy(layer, LayerInfo.class);
        } else
            return null;
    }

    public List<LayerInfo> getLayers(ResourceInfo resource) {

        List<LayerInfo> layers = catalogDAO.getLayersByResourceId(resource.getId());
        for (LayerInfo layer : layers) {
            resolve(layer);
        }
        return createProxyList(layers, LayerInfo.class);

    }

    public List<LayerInfo> getLayers(StyleInfo style) {
        List<LayerInfo> matches = new ArrayList<LayerInfo>();
        for (LayerInfo layer : catalogDAO.getLayers()) {
            if (style.equals(layer.getDefaultStyle()) || layer.getStyles().contains(style)) {
                resolve(layer);
                matches.add(layer);
            }
        }

        return createProxyList(matches, LayerInfo.class);
    }

    public List<LayerInfo> getLayers() {
        List<LayerInfo> layers = catalogDAO.getLayers();
        for (LayerInfo layerInfo : layers) {
            resolve(layerInfo);
        }
        return createProxyList(layers, LayerInfo.class);
    }

    // Map methods
    public MapInfo getMap(String id) {
        MapInfo map = catalogDAO.getMap(id);
        if (map != null) {
            resolve(map);
            return createProxy(map, MapInfo.class);
        }
        return null;

    }

    public MapInfo getMapByName(String name) {
        MapInfo map = catalogDAO.getMapByName(name);
        if (map != null) {
            resolve(map);
            return createProxy(map, MapInfo.class);
        }
        return null;

    }

    public List<MapInfo> getMaps() {
        List<MapInfo> maps = catalogDAO.getMaps();
        for (MapInfo map : maps) {
            resolve(map);
        }

        return createProxyList(maps, MapInfo.class);
    }

    public void add(LayerGroupInfo layerGroup) {
        validate(layerGroup, true);
        resolve(layerGroup);

        if (layerGroup.getStyles().isEmpty()) {
            for (LayerInfo l : layerGroup.getLayers()) {
                // default style
                layerGroup.getStyles().add(null);
            }
        }

        layerGroup = ModificationProxy.unwrap(layerGroup);
        catalogDAO.save(layerGroup);
        added(layerGroup);
    }

    void validate(LayerGroupInfo layerGroup, boolean isNew) {
        if (isNull(layerGroup.getName())) {
            throw new NullPointerException("Layer group name must not be null");
        }

        LayerGroupInfo existing = getLayerGroupByName(layerGroup.getName());
        if (existing != null && !existing.getId().equals(layerGroup.getId())) {
            throw new IllegalArgumentException("Layer group named '" + layerGroup.getName()
                    + "' already exists.");
        }

        if (!isNew) {
            if (layerGroup.getLayers() == null || layerGroup.getLayers().isEmpty()) {
                throw new NullPointerException("Layer group must not be empty");
            }
        }

        if (layerGroup.getStyles() != null && !layerGroup.getStyles().isEmpty()
                && !(layerGroup.getStyles().size() == layerGroup.getLayers().size())) {
            throw new IllegalArgumentException(
                    "Layer group has different number of styles than layers");
        }
    }

    public void remove(LayerGroupInfo layerGroup) {
        catalogDAO.delete(unwrap(layerGroup));
        removed(layerGroup);
    }

    public void save(LayerGroupInfo layerGroup) {
        validate(layerGroup, false);
        saved(layerGroup);
    }

    public List<LayerGroupInfo> getLayerGroups() {
        final List<LayerGroupInfo> layerGroups = catalogDAO.getLayerGroups();
        for (LayerGroupInfo layerGroupInfo : layerGroups) {
            resolve(layerGroupInfo);
        }
        return createProxyList(layerGroups, LayerGroupInfo.class);
    }

    public LayerGroupInfo getLayerGroup(String id) {
        final LayerGroupInfo layerGroup = catalogDAO.getLayerGroup(id);
        if (layerGroup != null) {
            resolve(layerGroup);
            return createProxy(layerGroup, LayerGroupInfo.class);
        } else
            return null;

    }

    public LayerGroupInfo getLayerGroupByName(String name) {
        LayerGroupInfo layerGroup = catalogDAO.getLayerGroupByName(name);
        if (layerGroup != null) {
            resolve(layerGroup);
            return createProxy(layerGroup, LayerGroupInfo.class);
        } else
            return null;
    }

    public void add(MapInfo map) {
        resolve(map);
        catalogDAO.save(ModificationProxy.unwrap(map));
        added(map);
    }

    public void remove(MapInfo map) {
        catalogDAO.delete(unwrap(map));
        removed(map);
    }

    public void save(MapInfo map) {
        saved(map);
    }

    // Namespace methods
    public NamespaceInfo getNamespace(String id) {
        final NamespaceInfo namespace = catalogDAO.getNamespace(id);
        if (namespace != null) {
            resolve(namespace);
            return createProxy(namespace, NamespaceInfo.class);
        } else
            return null;

    }

    public NamespaceInfo getNamespaceByPrefix(String prefix) {
        NamespaceInfo namespace = catalogDAO.getNamespaceByPrefix(prefix);
        if (namespace != null) {
            resolve(namespace);
            return createProxy(namespace, NamespaceInfo.class);
        } else
            return null;
    }

    public NamespaceInfo getNamespaceByURI(String uri) {
        NamespaceInfo namespace = catalogDAO.getNamespaceByURI(uri);
        if (namespace != null) {
            resolve(namespace);
            return createProxy(namespace, NamespaceInfo.class);
        } else
            return null;

    }

    public List<NamespaceInfo> getNamespaces() {
        final List<NamespaceInfo> namespaces = catalogDAO.getNamespaces();
        for (NamespaceInfo namespace : namespaces) {
            resolve(namespace);
        }
        return createProxyList(namespaces, NamespaceInfo.class);
    }

    public void add(NamespaceInfo namespace) {
        validate(namespace, true);
        resolve(namespace);

        boolean existsDefault = catalogDAO.getDefaultNamespace() != null;
        ((NamespaceInfoImpl) namespace).setDefault(!existsDefault);

        catalogDAO.save(namespace);

        added(namespace);
    }

    void validate(NamespaceInfo namespace, boolean isNew) {
        if (isNull(namespace.getPrefix())) {
            throw new NullPointerException("Namespace prefix must not be null");
        }

        NamespaceInfo existing = catalogDAO.getNamespaceByPrefix(namespace.getPrefix());
        if (existing != null && !existing.getId().equals(namespace.getId())) {
            throw new IllegalArgumentException("Namespace with prefix '" + namespace.getPrefix()
                    + "' already exists.");
        }

        if (namespace.getURI() == null) {
            throw new NullPointerException("Namespace uri must not be null");
        }

        if (isNull(namespace.getURI())) {
            throw new NullPointerException("Namespace uri must not be null");
        }

        try {
            new URI(namespace.getURI());
        } catch (Exception e) {
            throw new IllegalArgumentException("Invalid URI syntax for '" + namespace.getURI()
                    + "' in namespace '" + namespace.getPrefix() + "'");
        }
    }

    public void remove(NamespaceInfo namespace) {
        if (!catalogDAO.getResourcesByNamespace(namespace, ResourceInfo.class).isEmpty()) {
            throw new IllegalArgumentException("Unable to delete non-empty namespace.");
        }
        NamespaceInfoImpl realns = catalogDAO.getNamespaceByPrefix(namespace.getPrefix());
        if (realns == null) {
            throw new IllegalArgumentException("Can't find namespace '" + namespace.getPrefix()
                    + "' for deletion.");
        }

        catalogDAO.delete(realns);

        if (realns.isDefault()) {
            LOGGER.warning("Removing default namespace '" + namespace.getName() + "'");
            // elect a random ns as default
            List<NamespaceInfo> nslist = catalogDAO.getNamespaces();
            if (!nslist.isEmpty()) {
                NamespaceInfoImpl ns0 = (NamespaceInfoImpl) nslist.get(0);
                LOGGER.warning("Electing '" + namespace.getName() + "' to default namespace.");
                ns0.setDefault(true);
                catalogDAO.update(ns0);
            }
        }
        removed(namespace);
    }

    public void save(NamespaceInfo namespace) {
        validate(namespace, false);

        saved(namespace);
    }

    public NamespaceInfo getDefaultNamespace() {
        final NamespaceInfoImpl defaultNamespace = catalogDAO.getDefaultNamespace();
        resolve(defaultNamespace);
        return createProxy(defaultNamespace, NamespaceInfo.class);

    }

    public void setDefaultNamespace(NamespaceInfo defaultNamespace) {
        NamespaceInfo nsold = catalogDAO.getDefaultNamespace();
        NamespaceInfo nsnew = catalogDAO.getNamespaceByPrefix(defaultNamespace.getPrefix());
        if (nsnew == null) {
            throw new IllegalArgumentException("No such namespace: '"
                    + defaultNamespace.getPrefix() + "'");
        }

        if (nsold != null && nsold.getPrefix().equals(nsnew.getPrefix())) // setting existing
                                                                          // default
            return;

        ((NamespaceInfoImpl) nsnew).setDefault(true);
        catalogDAO.update(nsnew);
        if (nsold != null) {
            ((NamespaceInfoImpl) nsold).setDefault(false);
            catalogDAO.update(nsold);
        }

    }

    // Workspace methods
    public void add(WorkspaceInfo workspace) {
        validate(workspace, true);
        if (catalogDAO.getWorkspaceByName(workspace.getName()) != null) {
            throw new IllegalArgumentException("Workspace with name '" + workspace.getName()
                    + "' already exists.");
        }

        resolve(workspace);

        boolean existsDefault = catalogDAO.getDefaultWorkspace() != null;
        ((WorkspaceInfoImpl) workspace).setDefault(!existsDefault);

        catalogDAO.save(workspace);

        added(workspace);
    }

    void validate(WorkspaceInfo workspace, boolean isNew) {
        if (isNull(workspace.getName())) {
            throw new NullPointerException("workspace name must not be null");
        }

        WorkspaceInfo existing = catalogDAO.getWorkspaceByName(workspace.getName());
        if (existing != null && !existing.getId().equals(workspace.getId())) {
            throw new IllegalArgumentException("Workspace named '" + workspace.getName()
                    + "' already exists.");
        }

    }

    public void remove(WorkspaceInfo workspace) {
        // JD: maintain the link between namespace and workspace, remove this when this is no
        // longer necessary
        if (catalogDAO.getNamespaceByPrefix(workspace.getName()) != null) {
            throw new IllegalArgumentException("Cannot delete workspace with linked namespace");
        }
        if (!getStoresByWorkspace(workspace, StoreInfo.class).isEmpty()) {
            throw new IllegalArgumentException("Cannot delete non-empty workspace.");
        }
        catalogDAO.delete(workspace);
        removed(workspace);
    }

    public void save(WorkspaceInfo workspace) {
        validate(workspace, false);

        saved(workspace);
    }

    public WorkspaceInfo getDefaultWorkspace() {
        WorkspaceInfo workspace = catalogDAO.getDefaultWorkspace();
        if (workspace != null) {
            resolve(workspace);
            return createProxy(workspace, WorkspaceInfo.class);
        } else
            return null;

    }

    public void setDefaultWorkspace(WorkspaceInfo workspace) {

        WorkspaceInfo wsold = catalogDAO.getDefaultWorkspace();
        WorkspaceInfo wsnew = catalogDAO.getWorkspaceByName(workspace.getName());
        if (wsnew == null) {
            throw new IllegalArgumentException("No such workspace: '" + workspace.getName() + "'");
        }

        if (wsold != null && wsold.getName().equals(wsnew.getName())) // setting existing default
            return;

        ((WorkspaceInfoImpl) wsnew).setDefault(true);
        catalogDAO.update(wsnew);
        if (wsold != null) {
            ((WorkspaceInfoImpl) wsold).setDefault(false);
            catalogDAO.update(wsold);
        }

    }

    public List<WorkspaceInfo> getWorkspaces() {
        final List<WorkspaceInfo> workspaces = catalogDAO.getWorkspaces();
        for (WorkspaceInfo workspace : workspaces) {
            resolve(workspace);
        }
        return createProxyList(workspaces, WorkspaceInfo.class);

    }

    public WorkspaceInfo getWorkspace(String id) {
        WorkspaceInfo workspace = catalogDAO.getWorkspace(id);
        if (workspace != null) {
            resolve(workspace);
            return createProxy(workspace, WorkspaceInfo.class);
        } else
            return null;

    }

    public WorkspaceInfo getWorkspaceByName(String name) {
        WorkspaceInfo workspace = catalogDAO.getWorkspaceByName(name);
        if (workspace != null) {
            resolve(workspace);
            return createProxy(workspace, WorkspaceInfo.class);
        } else
            return null;

    }

    // Style methods
    public StyleInfo getStyle(String id) {
        StyleInfo style = catalogDAO.getStyle(id);
        if (style != null) {
            resolve(style);
            return createProxy(style, StyleInfo.class);
        } else
            return null;

    }

    public StyleInfo getStyleByName(String name) {
        StyleInfo style = catalogDAO.getStyleByName(name);
        if (style != null) {
            resolve(style);
            return createProxy(style, StyleInfo.class);
        } else
            return null;

    }

    public List<StyleInfo> getStyles() {
        final List<StyleInfo> styles = catalogDAO.getStyles();
        for (StyleInfo style : styles) {
            resolve(style);
        }

        return createProxyList(styles, StyleInfo.class);
    }

    public void add(StyleInfo style) {
        validate(style, true);
        resolve(style);
        catalogDAO.save(style);
        added(style);
    }

    void validate(StyleInfo style, boolean isNew) {
        if (isNull(style.getName())) {
            throw new NullPointerException("Style name must not be null");
        }
        if (isNull(style.getFilename())) {
            throw new NullPointerException("Style fileName must not be null");
        }

        StyleInfo existing = getStyleByName(style.getName());
        if (existing != null && !existing.getId().equals(style.getId())) {
            throw new IllegalArgumentException("Style named '" + style.getName()
                    + "' already exists.");
        }
    }

    public void remove(StyleInfo style) {
        // ensure no references to the style
        for (LayerInfo l : catalogDAO.getLayers()) {
            if (style.equals(l.getDefaultStyle()) || l.getStyles().contains(style)) {
                throw new IllegalArgumentException("Unable to delete style referenced by '"
                        + l.getName() + "'");
            }
        }
        StyleInfo realObj = catalogDAO.getStyle(style.getId());
        catalogDAO.delete(realObj);
        removed(style);
    }

    public void save(StyleInfo style) {
        validate(style, false);
        saved(style);
    }

    // Event methods
    public Collection getListeners() {
        return Collections.unmodifiableCollection(listeners);
    }

    public void addListener(CatalogListener listener) {
        listeners.add(listener);

    }

    public void removeListener(CatalogListener listener) {
        listeners.remove(listener);
    }

    public ResourcePool getResourcePool() {
        return resourcePool;
    }

    public void setResourcePool(ResourcePool resourcePool) {
        this.resourcePool = resourcePool;
    }

    public GeoServerResourceLoader getResourceLoader() {
        return resourceLoader;
    }

    public void setResourceLoader(GeoServerResourceLoader resourceLoader) {
        this.resourceLoader = resourceLoader;
    }

    public void dispose() {
        if (listeners != null)
            listeners.clear();

        if (resourcePool != null)
            resourcePool.dispose();
    }

    protected void added(CatalogInfo object) {
        fireAdded(object);
    }

    protected void fireAdded(CatalogInfo object) {
        CatalogAddEventImpl event = new CatalogAddEventImpl();
        event.setSource(object);

        event(event);
    }

    @SuppressWarnings("unchecked")
    protected void saved(CatalogInfo object) {
        // this object is a proxy
        if (!Proxy.isProxyClass(object.getClass())) {
            LOGGER.severe("WORKAROUND: CatalogInfo object is a "
                    + object.getClass().getSimpleName() + " -- Faking delta values in fireModified()");

            // fire out what changed
            List propertyNames = new ArrayList();
            List newValues = new ArrayList();
            List oldValues = new ArrayList();

            // TODO: protect this original object, perhaps with another proxy
            fireModified(object, propertyNames, oldValues, newValues);
            firePostModified(object);
            return;
        }

        ModificationProxy h = (ModificationProxy) Proxy.getInvocationHandler(object);

        // get the real object
        CatalogInfo real = (CatalogInfo) h.getProxyObject();

        // fire out what changed
        List propertyNames = h.getPropertyNames();
        List newValues = h.getNewValues();
        List oldValues = h.getOldValues();

        // TODO: protect this original object, perhaps with another proxy
        fireModified(real, propertyNames, oldValues, newValues);

        // commit to the original object
        h.commit();

        // resolve to do a sync on the object
        // syncIdWithName(real);

        // fire the post modify event
        firePostModified(real);
    }

    protected void fireModified(CatalogInfo object, List propertyNames, List oldValues,
            List newValues) {
        CatalogModifyEventImpl event = new CatalogModifyEventImpl();

        event.setSource(object);
        event.setPropertyNames(propertyNames);
        event.setOldValues(oldValues);
        event.setNewValues(newValues);

        event(event);
    }

    protected void firePostModified(CatalogInfo object) {
        CatalogPostModifyEventImpl event = new CatalogPostModifyEventImpl();
        event.setSource(object);

        event(event);
    }

    protected void removed(CatalogInfo object) {
        CatalogRemoveEventImpl event = new CatalogRemoveEventImpl();
        event.setSource(object);

        event(event);
    }

    protected void event(CatalogEvent event) {
        for (CatalogListener listener : listeners) {
            try {
                if (event instanceof CatalogAddEvent) {
                    listener.handleAddEvent((CatalogAddEvent) event);
                } else if (event instanceof CatalogRemoveEvent) {
                    listener.handleRemoveEvent((CatalogRemoveEvent) event);
                } else if (event instanceof CatalogModifyEvent) {
                    listener.handleModifyEvent((CatalogModifyEvent) event);
                } else if (event instanceof CatalogPostModifyEvent) {
                    listener.handlePostModifyEvent((CatalogPostModifyEvent) event);
                }
            } catch (Exception e) {
                LOGGER.log(Level.WARNING, "Catalog listener threw exception handling event.", e);
            }

        }
    }

    /**
     * Implementation method for resolving all {@link ResolvingProxy} instances.
     */
    public void resolve() {
        if (listeners == null) {
            listeners = new ArrayList<CatalogListener>();
        }

        if (resourcePool == null) {
            resourcePool = new ResourcePool(this);
        }
    }

    protected void resolve(WorkspaceInfo workspace) {
        resolveCollections(workspace);
    }

    protected void resolve(NamespaceInfo namespace) {
        resolveCollections(namespace);
    }

    protected void resolve(StoreInfo store) {
        StoreInfoImpl s = (StoreInfoImpl) store;

        // resolve the workspace
        WorkspaceInfo resolved = ResolvingProxy.resolve(this, s.getWorkspace());
        if (resolved != null) {
            s.setWorkspace(resolved);
        } else {
            // this means the workspace has not yet been added to the catalog, keep the proxy around
        }
        resolveCollections(s);

        s.setCatalog(this);
    }

    protected void resolve(ResourceInfo resource) {
        ResourceInfoImpl r = (ResourceInfoImpl) resource;

        // resolve the store
        StoreInfo resolved = ResolvingProxy.resolve(this, r.getStore());
        if (resolved != null) {
            resolve(resolved);
            r.setStore(resolved);
        }

        if (resource instanceof FeatureTypeInfo) {
            resolve((FeatureTypeInfo) resource);
        }
        if (r instanceof CoverageInfo) {
            resolve((CoverageInfo) resource);
        }

        r.setCatalog(this);
    }

    private void resolve(CoverageInfo r) {
        CoverageInfoImpl c = (CoverageInfoImpl) r;
        if (c.getDimensions() == null) {
            c.setDimensions(new ArrayList<CoverageDimensionInfo>());
        } else {
            for (CoverageDimensionInfo dim : c.getDimensions()) {
                if (dim.getNullValues() == null)
                    ((CoverageDimensionImpl) dim).setNullValues(new ArrayList<Double>());
            }
        }
        resolveCollections(r);
    }

    /**
     * We don't want the world to be able and call this without going trough
     * {@link #resolve(ResourceInfo)}
     * 
     * @param featureType
     */
    private void resolve(FeatureTypeInfo featureType) {
        FeatureTypeInfoImpl ft = (FeatureTypeInfoImpl) featureType;
        resolveCollections(ft);
    }

    protected void resolve(LayerInfo layer) {
        if (layer.getAttribution() == null) {
            layer.setAttribution(getFactory().createAttribution());
        }
        if (layer.getDefaultStyle() != null) {
            resolve(layer.getDefaultStyle());
        }
        resolve(layer.getResource());
        resolveCollections(layer);
    }

    protected void resolve(LayerGroupInfo layerGroup) {
        resolveCollections(layerGroup);
        LayerGroupInfoImpl lg = (LayerGroupInfoImpl) layerGroup;

        for (int i = 0; i < lg.getLayers().size(); i++) {
            LayerInfo l = lg.getLayers().get(i);
            LayerInfo resolved = ResolvingProxy.resolve(this, l);
            resolve(resolved);
            lg.getLayers().set(i, resolved);
        }

        for (int i = 0; i < lg.getStyles().size(); i++) {
            StyleInfo s = lg.getStyles().get(i);
            if (s != null) {
                StyleInfo resolved = ResolvingProxy.resolve(this, s);
                ((StyleInfoImpl)resolved).setCatalog(this);
                lg.getStyles().set(i, resolved);
            }
        }

    }

    protected void resolve(StyleInfo style) {
        ((StyleInfoImpl) style).setCatalog(this);
    }

    protected void resolve(MapInfo map) {
        for (LayerInfo layerInfo : map.getLayers()) {
            resolve(layerInfo);
        }
    }

    /**
     * Method which reflectively sets all collections when they are null.
     */
    protected void resolveCollections(Object object) {
        ClassProperties properties = OwsUtils.getClassProperties(object.getClass());
        for (String property : properties.properties()) {
            Method g = properties.getter(property, null);
            if (g == null) {
                continue;
            }

            Class type = g.getReturnType();
            // only continue if this is a collection or a map
            if (!(Map.class.isAssignableFrom(type) || Collection.class.isAssignableFrom(type))) {
                continue;
            }

            // only continue if there is also a setter as well
            Method s = properties.setter(property, null);
            if (s == null) {
                continue;
            }

            // if the getter returns null, call the setter
            try {
                Object value = g.invoke(object, null);
                if (value == null) {
                    if (Map.class.isAssignableFrom(type)) {
                        if (MetadataMap.class.isAssignableFrom(type)) {
                            value = new MetadataMap();
                        } else {
                            value = new HashMap();
                        }
                    } else if (List.class.isAssignableFrom(type)) {
                        value = new ArrayList();
                    } else if (Set.class.isAssignableFrom(type)) {
                        value = new HashSet();
                    } else {
                        throw new RuntimeException("Unknown collection type:" + type.getName());
                    }

                    // initialize
                    s.invoke(object, value);
                }
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        }
    }

    protected void setId(Object o) {
        if (OwsUtils.get(o, "id") == null) {
            String uid = new UID().toString();
            OwsUtils.set(o, "id", o.getClass().getSimpleName() + "-" + uid);
        }
    }

    protected boolean isNull(String string) {
        return string == null || "".equals(string.trim());
    }

    public static <T> T unwrap(T obj) {
        return ModificationProxy.unwrap(obj);
    }

    public void setCatalogDAO(CatalogDAO catalogDAO) {
        this.catalogDAO = catalogDAO;
    }

    class HibCatalogUpdater implements CatalogListener {

        public void handleAddEvent(CatalogAddEvent event) {
        }

        public void handleRemoveEvent(CatalogRemoveEvent event) {
        }

        public void handleModifyEvent(CatalogModifyEvent event) {
        }

        public void handlePostModifyEvent(CatalogPostModifyEvent event) {
            CatalogInfo src = event.getSource();
            src.accept(catalogVisitor);
        }

        public void reloaded() {
        }

        private CatalogVisitor catalogVisitor = new CatalogVisitor() {

            public void visit(WorkspaceInfo obj) {
                obj = ModificationProxy.unwrap(obj);
                catalogDAO.update(obj);
            }

            public void visit(NamespaceInfo obj) {
                obj = ModificationProxy.unwrap(obj);
                catalogDAO.update(obj);
            }

            public void visit(DataStoreInfo obj) {
                obj = ModificationProxy.unwrap(obj);
                catalogDAO.update(obj);
            }

            public void visit(CoverageStoreInfo obj) {
                obj = ModificationProxy.unwrap(obj);
                catalogDAO.update(obj);
            }

            public void visit(FeatureTypeInfo obj) {
                obj = ModificationProxy.unwrap(obj);
                catalogDAO.update(obj);
            }

            public void visit(CoverageInfo obj) {
                obj = ModificationProxy.unwrap(obj);
                catalogDAO.update(obj);
            }

            public void visit(LayerInfo obj) {
                obj = ModificationProxy.unwrap(obj);
                catalogDAO.update(obj);
            }

            public void visit(StyleInfo obj) {
                obj = ModificationProxy.unwrap(obj);
                catalogDAO.update(obj);
            }

            public void visit(LayerGroupInfo obj) {
                obj = ModificationProxy.unwrap(obj);
                catalogDAO.update(obj);
            }

            public void visit(Catalog catalog) {
            }
        };

    }

    public void accept(CatalogVisitor visitor) {
        visitor.visit(this);
    }

}