* (c) 2001 - 2013 OpenPlans

* This code is licensed under the GPL 2.0 license, available at the root

* application directory.

*/

* Utility class which loads and saves catalog and configuration objects to and

* from an xstream.

*

* @author Justin Deoliveira, The Open Planning Project

*

*/

    private boolean unwrapNulls = true;

  

    /**

     * Callback interface or xstream persister.

     */

    public static class Callback {

        protected void postEncodeWorkspace( WorkspaceInfo ws, HierarchicalStreamWriter writer, MarshallingContext context ) {

        }

       

        protected void postEncodeNamespace( NamespaceInfo ns, HierarchicalStreamWriter writer, MarshallingContext context ) {

        }

       

        protected void postEncodeDataStore( DataStoreInfo ds, HierarchicalStreamWriter writer, MarshallingContext context ) {

        }

       

        protected void postEncodeCoverageStore( CoverageStoreInfo ds, HierarchicalStreamWriter writer, MarshallingContext context ) {

        }

       

        protected void postEncodeFeatureType( FeatureTypeInfo ds, HierarchicalStreamWriter writer, MarshallingContext context ) {

        }

       

        protected void postEncodeWMSLayer( WMSLayerInfo ds, HierarchicalStreamWriter writer, MarshallingContext context ) {

        }

       

        protected void postEncodeCoverage( CoverageInfo ds, HierarchicalStreamWriter writer, MarshallingContext context ) {

        }

       

        protected void postEncodeLayer( LayerInfo ls, HierarchicalStreamWriter writer, MarshallingContext context ) {

        }

       

        protected void postEncodeLayerGroup( LayerGroupInfo ls, HierarchicalStreamWriter writer, MarshallingContext context ) {

        }

       

        /**

         * @deprecated use {@link #postEncodeReference(Object, String, String, HierarchicalStreamWriter, MarshallingContext)}

         */

        protected void postEncodeReference( Object obj, String ref, HierarchicalStreamWriter writer, MarshallingContext context ) {

        }

        protected void postEncodeReference( Object obj, String ref, String prefix, HierarchicalStreamWriter writer, MarshallingContext context ) {

            if (prefix == null) {

                //call other method for backward compatability

                postEncodeReference(obj, ref, writer, context);

            }

        }

        protected void postEncodeWMSStore(WMSStoreInfo store, HierarchicalStreamWriter writer,  MarshallingContext context) {

           

        }

    }

   

    /**

     * logging instance

     */

    static Logger LOGGER = Logging.getLogger( "org.geoserver" );

   

    /**

     * internal xstream instance

     */

    XStream xs;

    /**

     * GeoServer reference used to resolve references to gloal from services

     */

    GeoServer geoserver;

   

    /**

     * Catalog reference, used to resolve references to stores, workspaces

     * + namespaces

     */

    Catalog catalog;

   

    /**

     * Callback instance.

     */

    Callback callback;

   

    /**

     * Flag controlling how references to objects are encoded.

     */

    boolean referenceByName = false;

   

    /**

     * The type map used in {@link BreifMapConverter} to handle complex objects

     */

    Map<String, Class<?>> forwardBreifMap = new HashMap<String, Class<?>>();

    Map<Class<?>, String> backwardBreifMap = new HashMap<Class<?>, String>();

    private Level forceLevel = LOGGER.getLevel() == null? Level.INFO : LOGGER.getLevel();

   

    /**

     * Flag controlling whether the persister should perform encryption on password fields

     */

    boolean encryptPasswordFields = true;

    /**

     * Constructs the persister and underlying xstream.

     */

    protected XStreamPersister() {

        this(null);

    }

   

    /**

     * Constructs the persister and underlying xstream specifying the stream driver explicitly.

     */

    protected XStreamPersister(HierarchicalStreamDriver streamDriver) {

       

        //control the order in which fields are sorted

        SortableFieldKeySorter sorter = new SortableFieldKeySorter();

        //sorter.registerFieldOrder( DefaultCatalogDAO.class, new String[]{ "workspaces", "namespaces", "stores", "styles",

            /* these we actually omit, but the sorter needs them specified */

        //    "layerGroups", "resources", "maps", "defaultStores", "listeners", "layers",  "resourcePool", "resourceLoader", "LOGGER" } );

       

        ReflectionProvider reflectionProvider = new CustomReflectionProvider( new FieldDictionary( sorter ) );

            //new Sun14ReflectionProvider( new FieldDictionary( sorter  ) );

        if ( streamDriver != null ) {

            xs = new XStream( reflectionProvider, streamDriver );

        }

        else {

            xs = new XStream( reflectionProvider );   

        }

        xs.setMode(XStream.NO_REFERENCES);

       

        init(xs);

    }

   

    /**

     * Sets null handling in proxy objects.

     * Defaults to unwrap. If set to false, proxy object are not transformed to nulls.

     *

     * @param unwrapNulls

     */

    public void setUnwrapNulls(boolean unwrapNulls) {

        this.unwrapNulls = unwrapNulls;

    }

    protected void init(XStream xs) {

        // Default implementations

        initImplementationDefaults(xs);

       

        // ignore unkonwn fields, this should help using data dirs that has new config elements

        // with older versions of GeoServer

        xs.ignoreUnknownElements();

       

        // Aliases

        xs.alias("global", GeoServerInfo.class);

        xs.alias("settings", SettingsInfo.class);

        xs.alias("logging", LoggingInfo.class);

        xs.alias("jai", JAIInfo.class);

        xs.alias("coverageAccess", CoverageAccessInfo.class);

        xs.alias("catalog", Catalog.class);

        xs.alias("namespace", NamespaceInfo.class);

        xs.alias("workspace", WorkspaceInfo.class);

        xs.alias("dataStore", DataStoreInfo.class);

        xs.alias("wmsStore", WMSStoreInfo.class);

        xs.alias("coverageStore", CoverageStoreInfo.class);

        xs.alias("style",StyleInfo.class);

        xs.alias( "featureType", FeatureTypeInfo.class);

        xs.alias( "coverage", CoverageInfo.class);

        xs.alias( "wmsLayer", WMSLayerInfo.class);

        xs.alias( "coverageDimension", CoverageDimensionInfo.class);

        xs.alias( "coverageBand", CoverageBand.class);

        xs.alias( "inputCoverageBand", InputCoverageBand.class);

        xs.alias( "metadataLink", MetadataLinkInfo.class);

        xs.alias( "attribute", AttributeTypeInfo.class );

        xs.alias( "layer", LayerInfo.class);

        xs.alias( "layerGroup", LayerGroupInfo.class);

        xs.alias( "published", PublishedInfo.class);

        xs.alias( "gridGeometry", GridGeometry2D.class);

        xs.alias( "projected", DefaultProjectedCRS.class);

        xs.alias( "attribution", AttributionInfo.class );

        xs.aliasField("abstract", ResourceInfoImpl.class, "_abstract" );

        xs.alias("AuthorityURL", AuthorityURLInfo.class);

        xs.alias("Identifier", LayerIdentifierInfo.class);

        // GeoServerInfo

        xs.omitField(impl(GeoServerInfo.class), "clientProperties");

        xs.omitField(impl(GeoServerInfo.class), "geoServer");

        xs.registerLocalConverter(impl(GeoServerInfo.class), "metadata", new MetadataMapConverter());

        // ServiceInfo

        xs.omitField(impl(ServiceInfo.class), "clientProperties");

        xs.omitField(impl(ServiceInfo.class), "geoServer");

        xs.registerLocalConverter(impl(ServiceInfo.class), "workspace", new ReferenceConverter(WorkspaceInfo.class));

        xs.registerLocalConverter(impl(ServiceInfo.class), "metadata", new MetadataMapConverter());

        xs.registerLocalConverter(impl(ServiceInfo.class), "keywords", new KeywordListConverter());

        // Catalog

        xs.omitField(impl(Catalog.class), "resourcePool");

        xs.omitField(impl(Catalog.class), "resourceLoader");

        xs.omitField(impl(Catalog.class), "listeners");

        xs.omitField(impl(Catalog.class), "LOGGER");

       

        xs.omitField(impl(DefaultCatalogFacade.class), "catalog");

        xs.omitField(impl(DefaultCatalogFacade.class), "resources");

        xs.omitField(impl(DefaultCatalogFacade.class), "layers");

        xs.omitField(impl(DefaultCatalogFacade.class), "maps");

        xs.omitField(impl(DefaultCatalogFacade.class), "layerGroups");

       

        xs.registerLocalConverter(DefaultCatalogFacade.class, "stores",

                new StoreMultiHashMapConverter());

        xs.registerLocalConverter(DefaultCatalogFacade.class, "namespaces",

                new SpaceMapConverter("namespace"));

        xs.registerLocalConverter(DefaultCatalogFacade.class, "workspaces",

                new SpaceMapConverter("workspace"));

       

       

        //WorkspaceInfo

        xs.omitField( impl(WorkspaceInfo.class), "_default");

        xs.registerLocalConverter( impl(WorkspaceInfo.class), "metadata", new MetadataMapConverter() );

       

        //NamespaceInfo

        xs.omitField( impl(NamespaceInfo.class), "catalog");

        xs.omitField( impl(NamespaceInfo.class), "_default");

        xs.registerLocalConverter( impl(NamespaceInfo.class), "metadata", new MetadataMapConverter() );

       

        // StoreInfo

        xs.omitField(impl(StoreInfo.class), "catalog");

        xs.omitField(impl(StoreInfo.class), "error");

        //xs.omitField(StoreInfo.class), "workspace"); //handled by StoreInfoConverter

        xs.registerLocalConverter(impl(StoreInfo.class), "workspace", new ReferenceConverter(WorkspaceInfo.class));

        xs.registerLocalConverter(impl(StoreInfo.class), "connectionParameters", new BreifMapConverter() );

        xs.registerLocalConverter(impl(StoreInfo.class), "metadata", new MetadataMapConverter());

       

        // StyleInfo

        xs.omitField(impl(StyleInfo.class), "catalog");

        xs.registerLocalConverter(impl(StyleInfo.class), "workspace", new ReferenceConverter(WorkspaceInfo.class));

        xs.registerLocalConverter(impl(StyleInfo.class), "metadata", new MetadataMapConverter() );

       

        // ResourceInfo

        xs.omitField( impl(ResourceInfo.class), "catalog");

        xs.omitField( impl(ResourceInfo.class), "crs" );

        xs.registerLocalConverter( impl(ResourceInfo.class), "nativeCRS", new CRSConverter());

        xs.registerLocalConverter( impl(ResourceInfo.class), "store", new ReferenceConverter(StoreInfo.class));

        xs.registerLocalConverter( impl(ResourceInfo.class), "namespace", new ReferenceConverter(NamespaceInfo.class));

        xs.registerLocalConverter( impl(ResourceInfo.class), "metadata", new MetadataMapConverter() );

        xs.registerLocalConverter( impl(ResourceInfo.class), "keywords", new KeywordListConverter());

       

        // FeatureTypeInfo

       

        // CoverageInfo

        xs.registerLocalConverter( impl(CoverageInfo.class), "supportedFormats", new LaxCollectionConverter(xs.getMapper()));

        xs.registerLocalConverter( impl(CoverageInfo.class), "requestSRS", new LaxCollectionConverter(xs.getMapper()));

        xs.registerLocalConverter( impl(CoverageInfo.class), "responseSRS", new LaxCollectionConverter(xs.getMapper()));

        xs.registerLocalConverter( impl(CoverageInfo.class), "interpolationMethods", new LaxCollectionConverter(xs.getMapper()));

        xs.registerLocalConverter( impl(CoverageInfo.class), "dimensions", new LaxCollectionConverter(xs.getMapper()));

       

       

        // CoverageDimensionInfo

        xs.registerLocalConverter( impl(CoverageDimensionInfo.class), "range", new NumberRangeConverter());

       

        // AttributeTypeInfo

        xs.omitField( impl(AttributeTypeInfo.class), "featureType");

        xs.omitField( impl(AttributeTypeInfo.class), "attribute");

       

        // LayerInfo

        //xs.omitField( LayerInfo.class), "resource");

        xs.registerLocalConverter( impl(LayerInfo.class), "resource", new ReferenceConverter( ResourceInfo.class ) );

        xs.registerLocalConverter( impl(LayerInfo.class), "defaultStyle", new ReferenceConverter( StyleInfo.class) );

        xs.registerLocalConverter( impl(LayerInfo.class), "styles", new ReferenceCollectionConverter( StyleInfo.class ) );

        xs.registerLocalConverter( impl(LayerInfo.class), "metadata", new MetadataMapConverter() );

       

        // LayerGroupInfo

        xs.registerLocalConverter(impl(LayerGroupInfo.class), "workspace", new ReferenceConverter(WorkspaceInfo.class));

        xs.registerLocalConverter(impl(LayerGroupInfo.class), "rootLayer", new ReferenceConverter(LayerInfo.class));

        xs.registerLocalConverter(impl(LayerGroupInfo.class), "rootLayerStyle", new ReferenceConverter(StyleInfo.class));       

        xs.registerLocalConverter(impl(LayerGroupInfo.class), "layers", new ReferenceCollectionConverter( LayerInfo.class ));

        xs.registerLocalConverter(impl(LayerGroupInfo.class), "publishables", new ReferenceCollectionConverter( PublishedInfo.class, LayerInfo.class, LayerGroupInfo.class ));

        xs.registerLocalConverter(impl(LayerGroupInfo.class), "styles", new ReferenceCollectionConverter( StyleInfo.class ));

        xs.registerLocalConverter(impl(LayerGroupInfo.class), "metadata", new MetadataMapConverter() );

       

        //ReferencedEnvelope

        xs.registerLocalConverter( ReferencedEnvelope.class, "crs", new SRSConverter() );

        xs.registerLocalConverter( GeneralEnvelope.class, "crs", new SRSConverter() );

       

        // ServiceInfo

        xs.omitField( impl(ServiceInfo.class), "geoServer" );

        // Converters

        xs.registerConverter(new SpaceInfoConverter());

        xs.registerConverter(new StoreInfoConverter());

        xs.registerConverter(new ResourceInfoConverter());

        xs.registerConverter(new FeatureTypeInfoConverter());

        xs.registerConverter(new CoverageInfoConverter());

        xs.registerConverter(new LayerInfoConverter());

        xs.registerConverter(new LayerGroupInfoConverter());

        xs.registerConverter(new GridGeometry2DConverter());

        xs.registerConverter(new ProxyCollectionConverter( xs.getMapper() ) );

        xs.registerConverter(new VirtualTableConverter());

        xs.registerConverter(new KeywordInfoConverter());

        xs.registerConverter(new SettingsInfoConverter());

        xs.registerConverter(new MeasureConverter());

       

        // register Virtual structure handling

        registerBreifMapComplexType("virtualTable", VirtualTable.class);

        registerBreifMapComplexType("coverageView", CoverageView.class);

        registerBreifMapComplexType("dimensionInfo", DimensionInfoImpl.class);

        callback = new Callback();

    }

   

    /**

     * Use this method to register complex types that cannot be simply represented as a string

     * in a {@link BreifMapConverter}. The {@code typeId} will be used as a type discriminator

     * in the brief map, as well as the element root for the complex object to be converted.

     * @param typeId

     * @param clazz

     */

    public void registerBreifMapComplexType(String typeId, Class clazz) {

        forwardBreifMap.put(typeId, clazz);

        backwardBreifMap.put(clazz, typeId);

    }

    public XStream getXStream() {

        return xs;

    }

    public ClassAliasingMapper getClassAliasingMapper() {

        return (ClassAliasingMapper) xs.getMapper().lookupMapperOfType( ClassAliasingMapper.class );

    }

   

    public void setCatalog(Catalog catalog) {

        this.catalog = catalog;

    }

   

    public void setGeoServer(GeoServer geoserver) {

        this.geoserver = geoserver;

    }

    public GeoServerSecurityManager getSecurityManager() {

        return GeoServerExtensions.bean(GeoServerSecurityManager.class);

    }

    public void setCallback(Callback callback) {

        this.callback = callback;

    }

   

    public void setReferenceByName(boolean referenceByName) {

        this.referenceByName = referenceByName;

    }

   

    public void setExcludeIds() {

        xs.omitField(impl(WorkspaceInfo.class), "id");

        xs.omitField(impl(NamespaceInfo.class), "id");

        xs.omitField(impl(StoreInfo.class), "id");

        xs.omitField(impl(StyleInfo.class), "id");

        xs.omitField(impl(ResourceInfo.class), "id");

        xs.omitField(impl(LayerInfo.class), "id");

        xs.omitField(impl(LayerGroupInfo.class), "id" );

        xs.omitField(impl(AttributeTypeInfo.class), "id");

        xs.omitField(impl(ServiceInfo.class), "id");

    }

   

    public void setHideFeatureTypeAttributes() {

        xs.omitField(FeatureTypeInfoImpl.class, "attributes");

    }

    public void setEncryptPasswordFields(boolean encryptPasswordFields) {

        this.encryptPasswordFields = encryptPasswordFields;

    }

    public boolean isEncryptPasswordFields() {

        return encryptPasswordFields;

    }

    /**

     * Sets the minimum level at which messages should be logged by the persister.

     * <p>

     * When this level is set even messages that the underlying logger is configured to emit will

     * be skipped.

     * </p>

     */

    public void setLoggingLevel(Level level) {

        this.forceLevel = level;

    }

    /*

     * Helper to log a message forgoing if level is <= forceLevel.

     */

    void log(Level level, String msg) {

        if((LOGGER.isLoggable(level) && forceLevel.intValue() <= level.intValue())){

            LOGGER.log(level, msg);

        }

    }

    /**

     * Saves an object to persistence.

     *

     * @param obj The object to save.

     * @param out The stream to save the object to.

     *

     * @throws IOException

     */

    public void save(Object obj, OutputStream out) throws IOException {

        //unwrap dynamic proxies

        obj = unwrapProxies( obj );

        xs.toXML(obj, new OutputStreamWriter( out, "UTF-8" ));

    }

    /**

     * Unwraps any proxies around the object.

     * <p>

     * If the object is not being proxied it is passed back.

     * </p>

     */

    public static Object unwrapProxies( Object obj ) {

        obj = SecureCatalogImpl.unwrap( obj );

        obj = GeoServerImpl.unwrap( obj );

        obj = CatalogImpl.unwrap( obj );

        return obj;

    }

   

    /**

     * Loads an object from peristence.

     *

     * @param in The input stream to read the object from.

     * @param clazz The class of the expected object.

     *

     * @throws IOException

     */

    public <T> T load(InputStream in, Class<T> clazz ) throws IOException {

        T obj = clazz.cast( xs.fromXML( in ) );

       

        //call resolve() to ensure that any references created during loading

        // get resolved to actual objects, for instance for links from datastores

        // to workspaces

        if ( obj instanceof CatalogImpl ) {

            ((CatalogImpl)obj).resolve();

        }

       

        return obj;

    }

   

   

    /**

     * Builds a converter that will marshal/unmarshal the target class by reference, that is, by

     * storing the object id as opposed to fully serializing it

     * @param clazz

     * @return

     */

    public ReferenceConverter buildReferenceConverter(Class clazz) {

        return new ReferenceConverter(clazz);

    }

   

    /**

     * Same as {@link #buildReferenceConverter(Class)}, but works against a collection of objects

     * @param clazz

     * @return

     */

    public ReferenceCollectionConverter buildReferenceCollectionConverter(Class clazz) {

        return new ReferenceCollectionConverter(clazz);

    }

    /**

     * Sets up mappings from interface to implementation classes.

     *

     */

    protected void initImplementationDefaults(XStream xs) {

        //configuration

        xs.addDefaultImplementation(GeoServerInfoImpl.class, GeoServerInfo.class);

        xs.addDefaultImplementation(SettingsInfoImpl.class, SettingsInfo.class);

        xs.addDefaultImplementation(LoggingInfoImpl.class, LoggingInfo.class);

        xs.addDefaultImplementation(JAIInfoImpl.class, JAIInfo.class);

        xs.addDefaultImplementation(CoverageAccessInfoImpl.class, CoverageAccessInfo.class);

        xs.addDefaultImplementation(ContactInfoImpl.class, ContactInfo.class);

        xs.addDefaultImplementation(AttributionInfoImpl.class, AttributionInfo.class);

       

        //catalog

        xs.addDefaultImplementation(CatalogImpl.class, Catalog.class);

        xs.addDefaultImplementation(NamespaceInfoImpl.class, NamespaceInfo.class);

        xs.addDefaultImplementation(WorkspaceInfoImpl.class, WorkspaceInfo.class);

        xs.addDefaultImplementation(DataStoreInfoImpl.class, DataStoreInfo.class);

        xs.addDefaultImplementation(WMSStoreInfoImpl.class, WMSStoreInfo.class);

        xs.addDefaultImplementation(CoverageStoreInfoImpl.class, CoverageStoreInfo.class);

        xs.addDefaultImplementation(StyleInfoImpl.class, StyleInfo.class);

        xs.addDefaultImplementation(FeatureTypeInfoImpl.class, FeatureTypeInfo.class );

        xs.addDefaultImplementation(CoverageInfoImpl.class, CoverageInfo.class);

        xs.addDefaultImplementation(WMSLayerInfoImpl.class, WMSLayerInfo.class);

        xs.addDefaultImplementation(CoverageDimensionImpl.class, CoverageDimensionInfo.class);

        xs.addDefaultImplementation(MetadataLinkInfoImpl.class, MetadataLinkInfo.class);

        xs.addDefaultImplementation(AttributeTypeInfoImpl.class, AttributeTypeInfo.class );

        xs.addDefaultImplementation(LayerInfoImpl.class, LayerInfo.class);

        xs.addDefaultImplementation(LayerGroupInfoImpl.class, LayerGroupInfo.class );

        xs.addDefaultImplementation(LayerIdentifier.class, LayerIdentifierInfo.class );

        xs.addDefaultImplementation(AuthorityURL.class, AuthorityURLInfo.class );

        //supporting objects

        xs.addDefaultImplementation(GridGeometry2D.class, GridGeometry.class );

        xs.addDefaultImplementation(DefaultGeographicCRS.class, CoordinateReferenceSystem.class);

       

        //collections

        xs.addDefaultImplementation(ArrayList.class, List.class);

    }

   

    protected Class impl(Class interfce) {

        //special case case classes, they don't get registered as default implementations

        // only concrete classes do

        if (interfce == ServiceInfo.class) {

            return ServiceInfoImpl.class;

        }

        if (interfce == StoreInfo.class) {

            return StoreInfoImpl.class;

        }

        if (interfce == ResourceInfo.class) {

            return ResourceInfoImpl.class;

        }

       

        Class clazz = getXStream().getMapper().defaultImplementationOf(interfce);

        if (clazz == null) {

            throw new RuntimeException("No default mapping for " + interfce);

        }

        return clazz;

    }

   

    /**

     * Custom reflection provider which unwraps proxies, and skips empty collections

     * and maps.

     */

    class CustomReflectionProvider extends Sun14ReflectionProvider {

       

        public CustomReflectionProvider( FieldDictionary fd ) {

            super( fd );

        }

       

        @Override

        public void visitSerializableFields(Object object, Visitor visitor) {

            super.visitSerializableFields(object, new VisitorWrapper(visitor));

        }

       

        class VisitorWrapper implements ReflectionProvider.Visitor {

            Visitor wrapped;

           

            public VisitorWrapper( Visitor wrapped ) {

                this.wrapped = wrapped;

            }

           

            public void visit(String name, Class type, Class definedIn,

                    Object value) {

               

                //skip empty collections + maps

                if ( value instanceof Collection && ((Collection)value).isEmpty() ) {

                    return;

                }

                if ( value instanceof Map && ((Map)value).isEmpty() ) {

                    return;

                }

               

                //unwrap any proxies

                value = unwrapProxies(value);

                wrapped.visit( name, type, definedIn, value);

            }

           

        }

    }

    //

    // custom converters

    //

   

    //simple object converters

    /**

     * Map converter which encodes a map more breifly than the standard map converter.

     */

    protected class BreifMapConverter extends MapConverter {

       

        static final String ENCRYPTED_FIELDS_KEY = "org.geoserver.config.encryptedFields";

        public BreifMapConverter() {

            super(getXStream().getMapper());

        }

       

        @Override

        public boolean canConvert(Class type) {

            //handle all types of maps

            return Map.class.isAssignableFrom(type);

        }

        @Override

        public void marshal(Object source, HierarchicalStreamWriter writer,

                MarshallingContext context) {

            Set<String> encryptionFields = (Set<String>)context.get(ENCRYPTED_FIELDS_KEY);

            if (encryptionFields==null) {

                encryptionFields=Collections.emptySet();

            }

            GeoServerSecurityManager secMgr = encryptPasswordFields ? getSecurityManager() : null;

            Map map = (Map) source;

            for (Iterator iterator = map.entrySet().iterator(); iterator.hasNext();) {

                Map.Entry entry = (Map.Entry) iterator.next();

               

                if ( entry.getValue() == null ) {

                    continue;

                }

               

                writer.startNode("entry");

                writer.addAttribute( "key", entry.getKey().toString());

                if ( entry.getValue() != null ) {

                    Object value = entry.getValue();

                    String complexTypeId = getComplexTypeId(value.getClass());

                    if(complexTypeId == null) {

                        String str = Converters.convert(value, String.class);

                        if(str == null) {

                            str = value.toString();

                        }

                        if (encryptionFields.contains(entry.getKey()) && secMgr != null) {

                            str = secMgr.getConfigPasswordEncryptionHelper().encode(str);

                        }

                        writer.setValue(str);

                    } else {

                        writer.startNode(complexTypeId);

                        context.convertAnother(value);

                        writer.endNode();

                    }

                }

               

                writer.endNode();

            }

        }

        @Override

        protected void populateMap(HierarchicalStreamReader reader,

                UnmarshallingContext context, Map map) {

            while (reader.hasMoreChildren()) {

                reader.moveDown();

               

                //we support four syntaxes here:

                // 1) <key>value</key>

                // 2) <key><type>value</type></key>

                // 3) <entry key="">value</entry>

                // 4) <entry>

                //      <type>key</type>

                //      <type>value</type>

                //    </entry>

                String key = reader.getNodeName();

                Object value = null;

                if ( "entry".equals( key ) ) {

                    if ( reader.getAttribute( "key") != null ) {

                        //this is case 3

                        key = reader.getAttribute( "key" );

                        // in this case we also support complex objects

                        if(reader.hasMoreChildren()) {

                            reader.moveDown();

                            String typeId = reader.getNodeName();

                            value = context.convertAnother(null, getComplexTypeClass(typeId));

                            reader.moveUp();

                        } else {

                            value = reader.getValue();

                        }

                    }

                    else if ( reader.hasMoreChildren() ){

                        //this is case 4

                        reader.moveDown();

                       

                        key = reader.getValue();

                       

                        reader.moveUp();

                        reader.moveDown();

                       

                        value = reader.getValue();

                       

                        reader.moveUp();

                    }

                }

                else {

                    boolean old = false;

                    if (reader.hasMoreChildren()) {

                        //this handles case 2

                        old = true;

                        reader.moveDown();   

                    }

                   

                    value = readItem(reader, context, map);

                   

                    if ( old ) {

                        reader.moveUp();   

                    }

                }

              

                map.put(key, value);

                reader.moveUp();

            }

        }

       

        @Override

        protected Object readItem(HierarchicalStreamReader reader, UnmarshallingContext context,

                Object current) {

            return reader.getValue();

        }

        private Class getComplexTypeClass(String typeId) {

            return forwardBreifMap.get(typeId);

        }

       

        private String getComplexTypeId(Class clazz) {

             String typeId = backwardBreifMap.get(clazz);

             if(typeId == null) {

                 List<Class> matches = new ArrayList<Class>();

                 collectSuperclasses(clazz, matches);

                 for (Iterator it = matches.iterator(); it.hasNext();) {

                    Class sper = (Class) it.next();

                    if(backwardBreifMap.get(sper) == null) {

                        it.remove();

                    }

                }

                

                if(matches.size() > 1) {

                    Comparator comparator = new Comparator<Class>() {

                        public int compare(Class c1, Class c2) {

                            if (c2.isAssignableFrom(c1)) {

                                return -1;

                            } else {

                                return 1;

                            }

                        }

                    };

                    Collections.sort(matches, comparator);

                }

               

                if(matches.size() > 0) {

                    typeId = backwardBreifMap.get(matches.get(0));

                }

             }

            

             return typeId;

        }

        void collectSuperclasses(Class clazz, List<Class> matches) {

            matches.add(clazz);

            if(clazz.getSuperclass() == null && clazz.getInterfaces().length == 0) {