Application: gvSIG desktop

		ToolsLocator

				.registerPersistenceManager(XMLPersistenceManager.class);

		XMLPersistenceTest_Persistent.registerPersistent();

		XMLPersistenceTest_Persistent2.registerPersistent();

		XMLPersistenceTest_Persistent_ciclical.registerPersistent();

import java.util.Date;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dataTypes.DataTypes;

import org.gvsig.tools.dynobject.DynClass;

import org.gvsig.tools.dynobject.DynObjectManager;

	private static final Date UnDate = new Date(System.currentTimeMillis());

	/**

	 * Register the class on PersistenceManager

	 *

	 */

	public static void registerPersistent() {

		DynObjectManager dynMan = ToolsLocator.getDynObjectManager();

		DynClass dynClass = dynMan.add(

				"XMLPersistenceTest_Persistent_Persistent", "");

		dynClass.addDynFieldSingle("UnString", DataTypes.STRING, null, true,

				true);

		dynClass.addDynFieldSingle("UnStringValorLargo", DataTypes.STRING,

				null, true, true);

		dynClass.addDynFieldSingle("UnStringValorNoXML", DataTypes.STRING,

				null, true, true);

		dynClass

				.addDynFieldSingle("UnLong", DataTypes.LONG, null,

				true, true);

		dynClass

				.addDynFieldSingle("UnInteger", DataTypes.INT, null, true, true);

		dynClass.addDynFieldSingle("UnDouble", DataTypes.DOUBLE, null, true,

				true);

		dynClass

				.addDynFieldSingle("unList", DataTypes.LIST, null, true, true);

		dynClass.addDynFieldSingle("unListPorIterador", DataTypes.LIST, null,

				true, true);

		dynClass.addDynFieldSingle("unSet", DataTypes.SET, null, true, true);

		dynClass.addDynFieldSingle("yoMismo", DataTypes.OBJECT, null, true,

				true);

		dynClass.addDynFieldSingle("unMap", DataTypes.MAP, null, true, true);

		dynClass.addDynFieldSingle("otro_Objeto", DataTypes.OBJECT, null, true,

				true);

		dynClass.addDynFieldSingle("referencia_ciclica", DataTypes.OBJECT,

				null, true, true);

		dynClass.addDynFieldSingle("unDate", DataTypes.DATE, null, true, true);

		dynClass.addDynFieldSingle("UnBooleanoTrue", DataTypes.BOOLEAN, null,

				true, true);

		dynClass.addDynFieldSingle("UnBooleanoFalse", DataTypes.BOOLEAN, null,

				true, true);

		dynClass

				.addDynFieldSingle("UnNulo", DataTypes.STRING, null, true,

				true);

		ToolsLocator.getPersistenceManager().registerClass(

				XMLPersistenceTest_Persistent.class, dynClass);

	}

		assertEquals(UnDate, loaded.get("UnDate"));

		state.set("UnDate", UnDate);

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dataTypes.DataTypes;

import org.gvsig.tools.dynobject.DynClass;

import org.gvsig.tools.dynobject.DynObjectManager;

	/**

	 * Register the class on PersistenceManager

	 *

	 */

	public static void registerPersistent() {

		DynObjectManager dynMan = ToolsLocator.getDynObjectManager();

		DynClass dynClass = dynMan.add(

				"XMLPersistenceTest_Persistent2_Persistent", "");

		dynClass.addDynFieldSingle("ElObjeto2", DataTypes.STRING,

				null, true, true);

		ToolsLocator.getPersistenceManager().registerClass(

				XMLPersistenceTest_Persistent2.class, dynClass);

	}

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dataTypes.DataTypes;

import org.gvsig.tools.dynobject.DynClass;

import org.gvsig.tools.dynobject.DynObjectManager;

	/**

	 * Register the class on PersistenceManager

	 *

	 */

	public static void registerPersistent() {

		DynObjectManager dynMan = ToolsLocator.getDynObjectManager();

		DynClass dynClass = dynMan.add(

				"XMLPersistenceTest_Persistent_ciclical", "");

		dynClass.addDynFieldSingle("ElObjeto3", DataTypes.STRING, null, true,

				true);

		dynClass

				.addDynFieldSingle("Source", DataTypes.OBJECT, null, true,

				true);

		ToolsLocator.getPersistenceManager().registerClass(

				XMLPersistenceTest_Persistent_ciclical.class, dynClass);

	}

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

*

*/

/*

* AUTHORS (In addition to CIT):

* 2009 IVER T.I   {{Task}}

*/

/**

 *

 */

package org.gvsig.tools.persistence.xml;

import java.io.ByteArrayInputStream;

import java.io.ByteArrayOutputStream;

import java.io.File;

import java.io.FileOutputStream;

import java.util.ArrayList;

import java.util.Iterator;

import java.util.List;

import junit.framework.TestCase;

import org.gvsig.tools.ToolsLibrary;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.persistence.PersistenceManager;

import org.gvsig.tools.persistence.Persistent;

import org.gvsig.tools.persistence.PersistentState;

/**

 * @author jmvivo

 *

 */

public class ZipXMLPersistenceTest extends TestCase {

	/* (non-Javadoc)

	 * @see junit.framework.TestCase#setUp()

	 */

	protected void setUp() throws Exception {

		super.setUp();

		ToolsLibrary toolsLib = new ToolsLibrary();

		XMLPersistenceLibrary xmlPersistenceLib = new XMLPersistenceLibrary();

		toolsLib.initialize();

		xmlPersistenceLib.initialize();

		toolsLib.postInitialize();

		xmlPersistenceLib.postInitialize();

		ToolsLocator.registerPersistenceManager(ZipXMLPersistenceManager.class);

		XMLPersistenceTest_Persistent.registerPersistent();

		XMLPersistenceTest_Persistent2.registerPersistent();

		XMLPersistenceTest_Persistent_ciclical.registerPersistent();

	}

	public void test() throws Exception {

		Persistent myPersistent = new XMLPersistenceTest_Persistent();

		PersistenceManager manager = ToolsLocator.getPersistenceManager();

		PersistentState state = manager.getState(myPersistent);

		ByteArrayOutputStream out = new ByteArrayOutputStream(100 * 1024);

		manager.saveState(state, out);

		out.flush();

		byte[] bytesOut = out.toByteArray();

		File file = new File("out.zip");

		FileOutputStream fout = new FileOutputStream(file);

		fout.write(bytesOut);

		fout.flush();

		fout.close();

		System.out.println("Writed file:" + file.getAbsolutePath());

		ByteArrayInputStream in = new ByteArrayInputStream(bytesOut);

		PersistentState stateIn = manager.loadState(in);

		List names = new ArrayList();

		List namesIn = new ArrayList();

		Iterator iter = state.getNames();

		while (iter.hasNext()) {

			names.add(iter.next());

		}

		iter = stateIn.getNames();

		while (iter.hasNext()) {

			namesIn.add(iter.next());

		}

		assertEquals(names.size(), namesIn.size());

		iter = names.iterator();

		while (iter.hasNext()) {

			assertTrue(namesIn.contains(iter.next()));

		}

		Object loadedPersistent = manager.create(stateIn);

		assertTrue(loadedPersistent instanceof XMLPersistenceTest_Persistent);

		((XMLPersistenceTest_Persistent) loadedPersistent).checked();

	}

}

		myPersistenceManager.registerClass(DummyPersistent.class);

	public void testCreate() throws Exception {

		assertEquals(DummyPersistent.class, iter.next());

		myPersistenceManager.registerClass(aPersistent.getClass());

import java.util.Collections;

import java.util.TreeSet;

import java.util.Map.Entry;

import java.util.regex.Pattern;

import org.gvsig.tools.persistence.PersistenceClassNotRegistered;

import org.gvsig.tools.persistence.PersistenceRuntimeException;

	public static final String DEFAULT_DOMAIN_URL = "http://www.gvsig.org";

	public static final String DEFAULT_DOMAIN_NAME = "gvSIG";

	public static final Pattern VALID_DOMAIN_NAME_PATTERN = Pattern

			.compile("[\\w][\\d\\w_]*");

	protected Map domainsURL;

	private class ClassInfo {

		public DynStruct definition = null;

		public String domainName = null;

		public Object theClass = null;

	}

		domainsURL = new HashMap();

	public void addAlias(String name, Class aClass)

			throws PersistenceClassNotRegistered {

		ClassInfo info = (ClassInfo) classes.get(aClass.getName());

		if (info == null) {

			throw new PersistenceClassNotRegistered(aClass.getName());

		}

		classes.put(name, info);

			throws PersistenceException, PersistenceCreateException,

			PersistenceClassNotRegistered {

		// TODO IMPLEMENTAR FACTORY

			ClassInfo info = (ClassInfo) classes.get(className);

			if (info == null) {

				throw new PersistenceClassNotRegistered(className);

			}

			Object x = info.theClass;

		registerClass(persistentClass, definition, null);

		return getDefinition(persistentClass.getName());

		ClassInfo info = (ClassInfo) classes.get(persistentClassName);

		if (info == null) {

			return null;

		}

		return info.definition;

		Iterator iter = classes.values().iterator();

		Set classesSet = new TreeSet();

		ClassInfo info;

		while (iter.hasNext()) {

			info = (ClassInfo) iter.next();

			classesSet.add(info.theClass);

		}

		return classesSet.iterator();

			throws PersistenceException,

			PersistenceClassNotRegistered, PersistenceTypeNotSupportedException {

		String theClass = theOriginal.getClass().getName();

		state.setTheClassName(theClass);

		if (!classes.containsKey(theClass)) {

			throw new PersistenceClassNotRegistered(theClass);

		}

	 *

		registerClass(persistentClass, null, null, null);

			String domainName) {

		registerClass(persistentClass, definition, domainName, null);

	 * org.gvsig.tools.persistence.PersistenceManager#registerClass(java.lang

	 * .Class, org.gvsig.tools.dynobject.DynStruct, java.lang.String)

	 */

	public void registerClass(Class persistentClass, DynStruct definition,

			String domainName, String domainURL) {

		String domainURLStored = (String) domainsURL.get(domainName);

		String domainURLToUse;

		ClassInfo info = new ClassInfo();

		info.definition = definition;

		info.theClass = persistentClass;

		if (domainName == null) {

			info.domainName = DEFAULT_DOMAIN_NAME;

			domainURLToUse = DEFAULT_DOMAIN_URL;

		} else {

			if (!VALID_DOMAIN_NAME_PATTERN.matcher(domainName).matches()) {

				throw new PersistenceRuntimeException(

						"invalid domain name identifier: '" + domainName + "'");

			}

			info.domainName = domainName;

			if (domainURL == null) {

				if (domainURLStored == null) {

					domainURLToUse = DEFAULT_DOMAIN_URL;

				} else {

					domainURLToUse = domainURLStored;

				}

			} else {

				domainURLToUse = domainURL;

			}

		}

		if (domainURLStored == null) {

			domainsURL.put(info.domainName, domainURLToUse);

		} else if (!domainURLStored.equals(domainURLToUse)){

			throw new PersistenceRuntimeException("Domain URL conflict in "

					+ info.domainName + ": " + domainURLStored + " "

					+ domainURLToUse);

		}

		classes.put(persistentClass.getName(), info);

	}

	/*

	 * (non-Javadoc)

	 *

	 * @see

	 * @see org.gvsig.tools.persistence.impl.ImplementationPersistenceManager#

	 * @see org.gvsig.tools.persistence.impl.ImplementationPersistenceManager#

	 * @see org.gvsig.tools.persistence.impl.ImplementationPersistenceManager#

	/*

	 * (non-Javadoc)

	 *

	 * @see org.gvsig.tools.persistence.impl.ImplementationPersistenceManager#

	 * getDomainName(java.lang.String)

	 */

	public String getDomainName(String theClassName)

			throws PersistenceClassNotRegistered {

		ClassInfo info = (ClassInfo) classes.get(theClassName);

		if (info == null) {

			throw new PersistenceClassNotRegistered(theClassName);

		}

		return info.domainName;

	}

	/*

	 * (non-Javadoc)

	 *

	 * @see

	 * org.gvsig.tools.persistence.impl.ImplementationPersistenceManager#getDomains

	 * ()

	 */

	public Map getDomains() {

		return Collections.unmodifiableMap(domainsURL);

	}

	/*

	 * (non-Javadoc)

	 *

	 * @see org.gvsig.tools.persistence.impl.ImplementationPersistenceManager#

	 * getDomainURL(java.lang.String)

	 */

	public String getDomainURL(String domainName) {

		return (String) domainsURL.get(domainName);

	}

	/*

	 * (non-Javadoc)

	 *

	 * @see org.gvsig.tools.persistence.impl.ImplementationPersistenceManager#

	 * getDomainDefinitions(java.lang.String)

	 */

	public Map getDomainDefinitions(String domainName) {

		if (!domainsURL.containsKey(domainName)) {

			throw new PersistenceRuntimeException("Domain not registered");

		}

		Map definitions = new HashMap();

		Entry entry;

		ClassInfo info;

		Iterator iter = classes.entrySet().iterator();

		while (iter.hasNext()) {

			entry = (Entry) iter.next();

			info = (ClassInfo) entry.getValue();

			if (domainName.equals(info.domainName)) {

				definitions.put(entry.getKey(), info.definition);

			}

		}

		return definitions;

	}

import org.gvsig.tools.persistence.PersistenceClassNotRegistered;

	public String getDomainName(String theClassName)

			throws PersistenceClassNotRegistered;

	public String getDomainURL(String domainName);

	/**

	 * Return a read only Map with <code>domainName</code> as key and

	 * <code>domainURL</code> as value.

	 *

	 * @return Map<String,String>

	 */

	public Map getDomains();

	/**

	 * Return a read only Map with <code>className</code> as key and

	 * <code>definition</code> as value of a domainName.

	 * 

	 * @return Map<String,DynStruct>

	 */

	public Map getDomainDefinitions(String domainName);

	private final static String MESSAGE_KEY = "_PersistenceCreateException";

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

*

*/

/*

* AUTHORS (In addition to CIT):

* 2009 IVER T.I   {{Task}}

*/

/**

 *

 */

package org.gvsig.tools.persistence;

import java.util.Collections;

import java.util.Map;

/**

 * @author jmvivo

 *

 */

public class PersistenceClassNotRegistered extends PersistenceException {

	/**

	 *

	 */

	private static final long serialVersionUID = -5117203477405844983L;

	private final static String MESSAGE_FORMAT = "Class not registered in manager '%(class)'.";

	private final static String MESSAGE_KEY = "_PersistenceClassNotRegistered";

	private String theClass;

	public PersistenceClassNotRegistered(Class theClass) {

		this(theClass.getName());

	}

	public PersistenceClassNotRegistered(String theClass){

		super(MESSAGE_FORMAT, MESSAGE_KEY, serialVersionUID);

		this.theClass = theClass;

	}

	public String getTheClass() {

		return this.theClass;

	}

    protected Map values() {

		return Collections.singletonMap("class", theClass);

	}

}

	 * @throws PersistenceTypeNotSupportedException

	 * @throws PersistenceClassNotRegistered

			throws PersistenceException,

			PersistenceValidateExceptions,

			PersistenceTypeNotSupportedException, PersistenceClassNotRegistered;

	 * <p>

	 * Associates an alias with a class. This is similar to a symbolic link,

	 * which allows to access the class by means of its alias.

	 * </p>

	 * <p>

	 * When an alias is defined, it replaces any class whose qualified name is

	 * equal to the alias. Therefore, this class will never be instantiated, and

	 * instead the class pointed by the the alias will be instantiated.

	 * </p>

	 * <p>

	 * For example, if the following alias is defined:

	 * </p>

	 * <pre>

	 * Class aClass = org.gvsig.fmap.mapcontext.rendering.symbols.SimpleMarkerSymbol.class;

	 * manager

	 * 		.addAlias(

	 * 				"org.gvsig.fmap.mapcontext.rendering.symbols.ArrowMarkerSymbol",

	 * 				aClass);

	 * <p>

	 * then, SimpleMarkerSymbol will be instantiated instead of

	 * ArrowMarkerSymbol from any PersistentState which references

	 * ArrowMarkerSymbol.

	 * </p>

	 * <p>

	 * Aliases are useful to provided backward-compatibility paths (as old no

	 * existing classes may be aliased to substitution classes), but are also

	 * useful to avoid limitations on ClassLoaders. As a Class object is

	 * provided, it will be possible to instantiate it even if the current

	 * ClassLoader has no direct visibility of the class to instantiate.

	 * </p>

	 * @param alias

	 *            The alias to reference a class

	 * @param aClass

	 *            The class to be referenced by the alias

	 *

	 * @throws PersistenceClassNotRegistered

	 *             if <code>aClass</code> is not registered

	public void addAlias(String alias, Class aClass)

			throws PersistenceClassNotRegistered;

	 * manager with definition to validate it and a domainName identification.

	 * The domainURL will be the previously set, if it's not set will the gvSIG

	 * standard domainURL.

			String domainName);

	 * manager with definition to validate it and a domainName identification

	 * and the domainURL.

	 * </p>

	 *

	 *<p>

	 * <b>Note:</b> A <code>domainName</code> can by in only one

	 *<code>domainURL</code>. If you try to register the same

	 * <code>domainName</code> with two URL an exception will be raised.

	 *</p>

	 *

	 * @param persistentClass

	 *            The class to register

	 * @param definition

	 *            The definition of the attributes allowed for the

	 *            persistentClass

	 *

	 * @see #validateAll(PersistentState, int)

	 * @see #validateAll(PersistentState)

	 * @see #registerClass(Class)

	 * @see #create(PersistentState)

	 */

	public void registerClass(Class persistentClass, DynStruct definition,

			String domainName, String domainURL);

	/**

	 * <p>

	 * Register a class that implements {@link Persistent} for use in the

	 * @see #registerClass(Class, DynStruct, String)

	 *

	 * @throws PersistenceClassNotRegistered

	 *             if <code>persistentClass</code> is not registered

	public void unregisterClass(Class persistentClass)

			throws PersistenceClassNotRegistered;

	 *

	 * @throws PersistenceClassNotRegistered

	 *             if <code>className</code> is not registered

	public void unregisterClass(String className)

			throws PersistenceClassNotRegistered;

		ToolsLocator.registerPersistenceManager(ZipXMLPersistenceManager.class);

	 * XML Root item format.<br>

	 * Parameters:

	 * <ol>

	 * <li>domain notation (Ej. 'tools:')</li>

	 * <li>additional definitions</li>

	 * </ol>

	public static final String ROOT_VALUE = "<{0}" + ROOT_TAG

			+ " xmlns:xlink=\"http://www.w3.org/1999/xlink\" {1}>";

	public static final String BASE_DOMIAN_URL = "http://www.gvsig.org/libTools";

	public static final String BASE_DOMIAN_NAME = "tools";

	 * Schema File name format. <br>

	 * Parameters:

	 * <ol>

	 * <li>schema name</li>

	 * </ol>

	 *

	 */

	public static final String SCHEMA_FILE_NAME_VALUE = "{0}.xsd";

	/**

	 * Schema definition format<br>

	 * Parameters:

	 * <ol>

	 * <li>domain URL</li>

	 * <li>domain name</li>

	 * </ol>

	 */

	public static final String SCHEMA_DEFINITON_VALUE = "{0} {1}.xsd \n";

	/**

	 * SCHEMA attribute for ROOT tag.<br>

	 * Parameters:

	 * <ol>

	 * <li>Schema definition list</li>

	 * </ol>

	 */

	public static final String DEFAULT_SCHEMA_ATTRIBUTE_VALUE = INDENDT_3

			+ "xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"\n"

			+ "xsi:SchemaLocation=\"{0}\"";

	/**

	 * domain Name definition format. Parameters:

	 * <ol>

	 * <li>domain name</li>

	 * <li>domain URL</li>

	 * </ol>

	 */

	public static final String DOMAIN_NAME_ATTRIBUTE_VALUE = INDENDT_3

			+ "xmlns:{0}=\"{1}\"";

	/**

	 * <ol>

	 * <li>domain definition (Ej.: "tools:")</li>

	 * </ol>

	public static final String ROOT_END_VALUE = "</{0}" + ROOT_TAG + ">";

	 * <ol>

	 * <li>domain prefix (ex: 'aDomain:')</li>

	 * <li>theClassName</li>

	 * <li>id state</li>

	 * </ol>

	public static final String STATE_START = INDENDT_1 + "<{0}{1} "

			+ STATE_ID_ATTR + "=\"{2}\">";

	 * <li>domain prefix (ex: 'aDomain:')</li>

	 * <li>theClassName</li>

	public static final String STATE_END = INDENDT_1 + "</{0}{1}>";

	private static boolean useDomains = false;

		write(state, out, null);

	}

	public void write(ImplementationPersistentState state, OutputStream out,

			Map domains)

			throws PersistenceException {

		// Prepare schema

		String rootAttributes = "";

		if (domains != null && domains.size() > 0) {

			useDomains = true;

			StringBuffer buffRootAttr = new StringBuffer();

			buffRootAttr.append('\n');

			buffRootAttr.append(MessageFormat.format(

					DOMAIN_NAME_ATTRIBUTE_VALUE, new Object[] {

							BASE_DOMIAN_NAME, BASE_DOMIAN_URL }));

			Iterator iter = domains.entrySet().iterator();

			Entry entry;

			while (iter.hasNext()) {

				entry = (Entry) iter.next();

				buffRootAttr.append('\n');

				buffRootAttr.append(MessageFormat.format(DOMAIN_NAME_ATTRIBUTE_VALUE,

						new Object[] { entry.getKey(), entry.getValue() }));

			}

			iter = domains.entrySet().iterator();

			StringBuffer buffSchemas = new StringBuffer();

			buffSchemas.append('\n');

			buffSchemas.append(MessageFormat.format(SCHEMA_DEFINITON_VALUE,

					new Object[] { BASE_DOMIAN_NAME, BASE_DOMIAN_URL }));

			while (iter.hasNext()) {

				entry = (Entry) iter.next();

				buffSchemas.append('\n');

				buffSchemas.append(MessageFormat.format(SCHEMA_DEFINITON_VALUE,

						new Object[] { entry.getValue(), entry.getKey() }));

			}

			buffRootAttr.append('\n');

			buffRootAttr.append(MessageFormat.format(DEFAULT_SCHEMA_ATTRIBUTE_VALUE,

					new Object[] { buffSchemas.toString() }));

			rootAttributes = buffRootAttr.toString();

		}

//		if (useDomains) {

//			print.println(MessageFormat.format(ROOT_VALUE, new Object[] {

//					BASE_DOMIAN_NAME + ":", rootAttributes }));

//		} else {

			print.println(MessageFormat.format(ROOT_VALUE,

					new Object[] { "",

					rootAttributes }));

//		}

//		if (useDomains) {

//			print.println(MessageFormat.format(ROOT_END_VALUE,

//					new Object[] { BASE_DOMIAN_NAME + ":" }));

//		} else {

			print.println(MessageFormat.format(ROOT_END_VALUE,

					new Object[] { "" }));

//		}

		String theClassName = curState.getTheClassName();

		String domainName = "";

		if (useDomains) {

			domainName = manager.getDomainName(theClassName) + ":";

		}

				domainName, theClassName, curState.getId() }));

				domainName, theClassName, curState.getId() }));

		return TYPE_DATE;

		XMLPersistentStateReader xmlReader = getReaderInstance();

		XMLPersistentStateWriter xmlWriter = getWriterInstance();

	protected XMLPersistentStateReader getReaderInstance(){

		return new XMLPersistentStateReader(this);

	}

	protected XMLPersistentStateWriter getWriterInstance() {

		return new XMLPersistentStateWriter(this);

	}

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

*

*/

/*

* AUTHORS (In addition to CIT):

* 2009 IVER T.I   {{Task}}

*/

/**

 *

 */

package org.gvsig.tools.persistence.xml;

import java.text.MessageFormat;

/**

 * @author jmvivo

 *

 */

public interface ZipXMLSchemaConstants {

	/**

	 * <ol>

	 * <li>domain name</li>

	 * <li>domain URL</li>

	 * </ol>

	 */

	public static final String XSD_IMPORT_SCHEMA_VALUE =

		"<xs:import namespace=\"{1}\" schemaLocation=\"{0}\"/>\n\n";

	/**

	 * Current Schema file name.

	 */

	public static final String BASE_SCHEMA_FILE_NAME = MessageFormat.format(

			XMLPersistentConstants.SCHEMA_FILE_NAME_VALUE,

			new Object[] { "persistentState_base" });

	/**

	 * <ol>

	 * <li>domain name</li>

	 * <li>domain URL</li>

	 * </ol>

	 */

	public static final String XSD_HEAD_VALUE =

			"<?xml version=\"1.0\"?>\n"+

			"<xs:schema xmlns:xs=\"http://www.w3.org/2001/XMLSchema\"\n"+

			"  targetNamespace=\"{1}\"" +

			"  xmlns:tools=\""+XMLPersistentConstants.BASE_DOMIAN_URL+"\"\n"+

			"  xmlns:{0}=\"{1}\"\n"+

			"  elementFormDefault=\"qualified\"\n"+

			"  attributeFormDefault=\"qualified\">"+

			MessageFormat.format(

				XSD_IMPORT_SCHEMA_VALUE,

				new Object[] {

					BASE_SCHEMA_FILE_NAME,

					XMLPersistentConstants.BASE_DOMIAN_URL });

	public static final String XSD_END = "</xs:schema>";

	/**

	 * <ol>

	 * <li>class name</li>

	 * </ol>

	 */

	public static final String XSD_START_CLASS_VALUE =

		"    <xs:element name=\"{0}\">\n" +

        "      <xs:complexType>\n" +

        "        <xs:all>\n";

	public static final String XSD_END_CLASS =

		"        </xs:all>\n" +

		"        <xs:attributeGroup ref=\"tools:state_attributes\"/>"+

        "      </xs:complexType>\n" +

		"    </xs:element>\n";

	/**

	 * <ol>

	 * <li>attribute name</li>

	 * <li>attribute type (use

	 *   {@link #XSD_ATTRUBUTE_TYPE_INTEGER},

	 *   {@link #XSD_ATTRUBUTE_TYPE_LONG},

	 *   {@link #XSD_ATTRUBUTE_TYPE_NULL},

	 *   etc..

	 *    ) </li>

	 * </ol>

	 */

	public static final String XSD_ATTRUBUTE_VALUE =

		"          <xs:element name=\"{0}\" type=\"{1}\"/>";

	/**

	 * <ol>

	 * <li>attribute name</li>

	 * <li>attribute type (use {@link #XSD_ATTRUBUTE_TYPE_INTEGER},

	 * {@link #XSD_ATTRUBUTE_TYPE_LONG}, {@link #XSD_ATTRUBUTE_TYPE_STRING},

	 * etc.. )</li>

	 * </ol>

	 */

	public static final String XSD_ATTRUBUTE_MANDATORY_VALUE =

		"          <xs:element name=\"{0}\" type=\"{1}\" minOccurs=\"1\"/>";

	public static final String XSD_ATTRUBUTE_TYPE_NULL = "tools:state_attribute_Null";