diff --git a/pom.xml b/pom.xml new file mode 100644 index 000000000..2a4b23796 --- /dev/null +++ b/pom.xml @@ -0,0 +1,75 @@ + + + + li.strolch + li.strolch.parent + 0.1.0-SNAPSHOT + ../li.strolch.parent/pom.xml + + + 4.0.0 + + li.strolch.persistence.xml + + Reference Persistence Implementation for Strolch + Reference Persistence Implementation for Strolch + + https://github.com/eitch/li.strolch.persistence.xml + + 2011 + + + Github Issues + https://github.com/eitch/li.strolch.persistence.xml/issues + + + + scm:git:https://github.com/eitch/li.strolch.persistence.xml.git + scm:git:git@github.com:eitch/li.strolch.persistence.xml.git + https://github.com/eitch/li.strolch.persistence.xml + + + + + + li.strolch + li.strolch.model + + + li.strolch + li.strolch.persistence.api + + + + ch.eitchnet + ch.eitchnet.xmlpers + + + + + + + + org.apache.maven.plugins + maven-eclipse-plugin + + + org.apache.maven.plugins + maven-compiler-plugin + + + org.apache.maven.plugins + maven-source-plugin + + + org.apache.maven.plugins + maven-jar-plugin + + + org.apache.maven.plugins + maven-site-plugin + + + + \ No newline at end of file diff --git a/src/main/java/li/strolch/persistence/impl/AbstractDao.java b/src/main/java/li/strolch/persistence/impl/AbstractDao.java new file mode 100644 index 000000000..fb41b4c16 --- /dev/null +++ b/src/main/java/li/strolch/persistence/impl/AbstractDao.java @@ -0,0 +1,120 @@ +package li.strolch.persistence.impl; + +import java.util.ArrayList; +import java.util.HashSet; +import java.util.List; +import java.util.Set; + +import li.strolch.model.StrolchElement; +import li.strolch.persistence.api.StrolchDao; +import li.strolch.persistence.api.StrolchTransaction; +import ch.eitchnet.xmlpers.api.PersistenceTransaction; +import ch.eitchnet.xmlpers.objref.IdOfSubTypeRef; +import ch.eitchnet.xmlpers.objref.SubTypeRef; +import ch.eitchnet.xmlpers.objref.TypeRef; + +public abstract class AbstractDao implements StrolchDao { + + protected PersistenceTransaction tx; + + protected AbstractDao(StrolchTransaction tx) { + XmlStrolchTransaction strolchTx = (XmlStrolchTransaction) tx; + this.tx = strolchTx.getTx(); + } + + protected abstract String getClassType(); + + protected IdOfSubTypeRef getIdRef(String type, String id) { + IdOfSubTypeRef idRef = this.tx.getObjectRefCache().getIdOfSubTypeRef(getClassType(), type, id); + return idRef; + } + + protected SubTypeRef getTypeRef(String type) { + SubTypeRef typeRef = this.tx.getObjectRefCache().getSubTypeRef(getClassType(), type); + return typeRef; + } + + @Override + public Set queryKeySet() { + Set keys = new HashSet<>(); + Set types = queryTypes(); + for (String type : types) { + keys.addAll(queryKeySet(type)); + } + return keys; + } + + @Override + public Set queryKeySet(String type) { + SubTypeRef typeRef = this.tx.getObjectRefCache().getSubTypeRef(getClassType(), type); + Set keys = this.tx.getMetadataDao().queryKeySet(typeRef); + return keys; + } + + @Override + public Set queryTypes() { + TypeRef typeRef = this.tx.getObjectRefCache().getTypeRef(getClassType()); + Set types = this.tx.getMetadataDao().queryTypeSet(typeRef); + return types; + } + + @Override + public T queryBy(String type, String id) { + T t = this.tx.getObjectDao().queryById(getIdRef(type, id)); + return t; + } + + @Override + public List queryAll() { + List objects = new ArrayList<>(); + Set types = queryTypes(); + for (String type : types) { + List objectsByType = this.tx.getObjectDao().queryAll(getTypeRef(type)); + objects.addAll(objectsByType); + } + + return objects; + } + + @Override + public List queryAll(String type) { + List objectsByType = this.tx.getObjectDao().queryAll(getTypeRef(type)); + return objectsByType; + } + + @Override + public void save(T object) { + this.tx.getObjectDao().add(object); + } + + @Override + public void saveAll(List objects) { + this.tx.getObjectDao().addAll(objects); + } + + @Override + public void update(T object) { + this.tx.getObjectDao().update(object); + } + + @Override + public void updateAll(List objects) { + this.tx.getObjectDao().updateAll(objects); + } + + @Override + public void remove(T object) { + this.tx.getObjectDao().remove(object); + } + + @Override + public void removeAll(List objects) { + this.tx.getObjectDao().removeAll(objects); + } + + @Override + public void remove(String type, String id) { + IdOfSubTypeRef objectRef = this.tx.getObjectRefCache().getIdOfSubTypeRef(getClassType(), type, id); + this.tx.getObjectDao().removeById(objectRef); + } +} diff --git a/src/main/java/li/strolch/persistence/impl/StrolchPersistenceHandlerImpl.java b/src/main/java/li/strolch/persistence/impl/StrolchPersistenceHandlerImpl.java new file mode 100644 index 000000000..df2a919bc --- /dev/null +++ b/src/main/java/li/strolch/persistence/impl/StrolchPersistenceHandlerImpl.java @@ -0,0 +1,68 @@ +/* + * Copyright (c) 2012, Robert von Burg + * + * All rights reserved. + * + * This file is part of the ch.eitchnet.persistence.impl. + * + * ch.eitchnet.persistence.impl is free software: you can redistribute + * it and/or modify it under the terms of the GNU General Public License as + * published by the Free Software Foundation, either version 3 of the License, + * or (at your option) any later version. + * + * ch.eitchnet.persistence.impl 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 ch.eitchnet.persistence.impl. If not, see + * . + */ +package li.strolch.persistence.impl; + +import java.util.Properties; + +import li.strolch.persistence.api.OrderDao; +import li.strolch.persistence.api.ResourceDao; +import li.strolch.persistence.api.StrolchPersistenceHandler; +import li.strolch.persistence.api.StrolchTransaction; +import ch.eitchnet.xmlpers.api.PersistenceManager; +import ch.eitchnet.xmlpers.api.PersistenceManagerLoader; +import ch.eitchnet.xmlpers.api.PersistenceTransaction; + +/** + * @author Robert von Burg + * + */ +public class StrolchPersistenceHandlerImpl implements StrolchPersistenceHandler { + + private PersistenceManager persistenceManager; + + public void initialize() { + Properties properties = new Properties(); + this.persistenceManager = PersistenceManagerLoader.load(properties); + } + + public StrolchTransaction openTx() { + return openTx(PersistenceManager.DEFAULT_REALM); + } + + @SuppressWarnings("resource") // caller must close + public StrolchTransaction openTx(String realm) { + PersistenceTransaction tx = this.persistenceManager.openTx(realm); + XmlStrolchTransaction strolchTx = new XmlStrolchTransaction(tx); + return strolchTx; + } + + @Override + public OrderDao getOrderDao(StrolchTransaction tx) { + return new XmlOrderDao(tx); + } + + @Override + public ResourceDao getResourceDao(StrolchTransaction tx) { + return new XmlResourceDao(tx); + } + +} diff --git a/src/main/java/li/strolch/persistence/impl/XmlOrderDao.java b/src/main/java/li/strolch/persistence/impl/XmlOrderDao.java new file mode 100644 index 000000000..86e48e844 --- /dev/null +++ b/src/main/java/li/strolch/persistence/impl/XmlOrderDao.java @@ -0,0 +1,19 @@ +package li.strolch.persistence.impl; + +import li.strolch.model.Order; +import li.strolch.persistence.api.OrderDao; +import li.strolch.persistence.api.StrolchTransaction; + +public class XmlOrderDao extends AbstractDao implements OrderDao { + + private static final String CLASS_TYPE = Order.class.getName(); + + protected XmlOrderDao(StrolchTransaction tx) { + super(tx); + } + + @Override + protected String getClassType() { + return CLASS_TYPE; + } +} diff --git a/src/main/java/li/strolch/persistence/impl/XmlResourceDao.java b/src/main/java/li/strolch/persistence/impl/XmlResourceDao.java new file mode 100644 index 000000000..64c9e06cf --- /dev/null +++ b/src/main/java/li/strolch/persistence/impl/XmlResourceDao.java @@ -0,0 +1,19 @@ +package li.strolch.persistence.impl; + +import li.strolch.model.Resource; +import li.strolch.persistence.api.ResourceDao; +import li.strolch.persistence.api.StrolchTransaction; + +public class XmlResourceDao extends AbstractDao implements ResourceDao { + + private static final String CLASS_TYPE = Resource.class.getName(); + + protected XmlResourceDao(StrolchTransaction tx) { + super(tx); + } + + @Override + protected String getClassType() { + return CLASS_TYPE; + } +} diff --git a/src/main/java/li/strolch/persistence/impl/XmlStrolchTransaction.java b/src/main/java/li/strolch/persistence/impl/XmlStrolchTransaction.java new file mode 100644 index 000000000..54448d15a --- /dev/null +++ b/src/main/java/li/strolch/persistence/impl/XmlStrolchTransaction.java @@ -0,0 +1,45 @@ +package li.strolch.persistence.impl; + +import li.strolch.persistence.api.StrolchPersistenceException; +import li.strolch.persistence.api.StrolchTransaction; +import li.strolch.persistence.api.TransactionCloseStrategy; +import ch.eitchnet.xmlpers.api.PersistenceTransaction; + +public class XmlStrolchTransaction implements StrolchTransaction { + + private PersistenceTransaction tx; + private TransactionCloseStrategy closeStrategy; + + public XmlStrolchTransaction(PersistenceTransaction tx) { + this.tx = tx; + } + + PersistenceTransaction getTx() { + return this.tx; + } + + @Override + public void setCloseStrategy(TransactionCloseStrategy closeStrategy) { + this.closeStrategy = closeStrategy; + } + + @Override + public void autoCloseableCommit() { + this.tx.autoCloseableCommit(); + } + + @Override + public void autoCloseableRollback() { + this.tx.autoCloseableRollback(); + } + + @Override + public void close() throws StrolchPersistenceException { + this.closeStrategy.close(this); + } + + @Override + public boolean isOpen() { + return this.tx.isOpen(); + } +} diff --git a/src/test/java/li/strolch/persistence/impl/dao/test/AbstractDaoImplTest.java b/src/test/java/li/strolch/persistence/impl/dao/test/AbstractDaoImplTest.java new file mode 100644 index 000000000..f3beb7faf --- /dev/null +++ b/src/test/java/li/strolch/persistence/impl/dao/test/AbstractDaoImplTest.java @@ -0,0 +1,31 @@ +/* + * Copyright (c) 2012, Robert von Burg + * + * All rights reserved. + * + * This file is part of the XXX. + * + * XXX is free software: you can redistribute + * it and/or modify it under the terms of the GNU General Public License as + * published by the Free Software Foundation, either version 3 of the License, + * or (at your option) any later version. + * + * XXX 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 XXX. If not, see + * . + */ +package li.strolch.persistence.impl.dao.test; + +/** + * @author Robert von Burg + * + */ +public class AbstractDaoImplTest { + + +} diff --git a/src/test/java/li/strolch/persistence/impl/dao/test/XmlOrderDaoTest.java b/src/test/java/li/strolch/persistence/impl/dao/test/XmlOrderDaoTest.java new file mode 100644 index 000000000..a72d156b5 --- /dev/null +++ b/src/test/java/li/strolch/persistence/impl/dao/test/XmlOrderDaoTest.java @@ -0,0 +1,14 @@ +package li.strolch.persistence.impl.dao.test; + +import static org.junit.Assert.*; + +import org.junit.Test; + +public class XmlOrderDaoTest { + + @Test + public void test() { + fail("Not yet implemented"); + } + +}