Add lazy track implementation and creator.

[demoscenemusic.git] / src / main / java / net / pterodactylus / demoscenemusic / data / DataManager.java

diff --git a/src/main/java/net/pterodactylus/demoscenemusic/data/DataManager.java b/src/main/java/net/pterodactylus/demoscenemusic/data/DataManager.java
index 7e74ea9..5523bbe 100644 (file)
--- a/src/main/java/net/pterodactylus/demoscenemusic/data/DataManager.java
+++ b/src/main/java/net/pterodactylus/demoscenemusic/data/DataManager.java
@@ -31,6 +31,7 @@ import net.pterodactylus.util.database.DatabaseException;
 import net.pterodactylus.util.database.Field;
 import net.pterodactylus.util.database.Join;
 import net.pterodactylus.util.database.Join.JoinType;
+import net.pterodactylus.util.database.ObjectCreator;
 import net.pterodactylus.util.database.OrderField;
 import net.pterodactylus.util.database.OrderField.Order;
 import net.pterodactylus.util.database.Parameter.StringParameter;
@@ -47,6 +48,10 @@ import net.pterodactylus.util.database.ValueFieldWhereClause;
  */
 public class DataManager {
 
+       private final ObjectCreator<Artist> artistCreator = new ArtistCreator();
+       private final ObjectCreator<Group> groupCreator = new GroupCreator();
+       private final ObjectCreator<Track> trackCreator = new TrackCreator();
+
        private final Database database;
 
        public DataManager(Database database) {
@@ -56,28 +61,22 @@ public class DataManager {
        public Collection<Artist> getAllArtists() throws DatabaseException {
                Query query = new Query(Type.SELECT, "ARTISTS");
                query.addField(new Field("ARTISTS.*"));
-               query.addField(new Field("GROUP_ARTISTS.*"));
-               query.addField(new Field("GROUPS.*"));
-               query.addJoin(new Join(JoinType.INNER, "GROUP_ARTISTS", new Field("ARTISTS.ID"), new Field("GROUP_ARTISTS.ARTIST")));
-               query.addJoin(new Join(JoinType.INNER, "GROUPS", new Field("GROUP_ARTISTS.GROUP_"), new Field("GROUPS.ID")));
-               query.addOrderField(new OrderField(new Field("ARTISTS.ID")));
-               ArtistLoader artistLoader = new ArtistLoader();
-               database.process(query, artistLoader);
-               return artistLoader.all();
+               return database.getMultiple(query, artistCreator);
        }
 
        public Artist getArtistById(String id) throws DatabaseException {
                Query query = new Query(Type.SELECT, "ARTISTS");
                query.addField(new Field("ARTISTS.*"));
-               query.addField(new Field("GROUP_ARTISTS.*"));
-               query.addField(new Field("GROUPS.*"));
-               query.addJoin(new Join(JoinType.INNER, "GROUP_ARTISTS", new Field("ARTISTS.ID"), new Field("GROUP_ARTISTS.ARTIST")));
-               query.addJoin(new Join(JoinType.INNER, "GROUPS", new Field("GROUP_ARTISTS.GROUP_"), new Field("GROUPS.ID")));
                query.addWhereClause(new ValueFieldWhereClause(new ValueField("ARTISTS.ID", new StringParameter(id))));
-               query.addOrderField(new OrderField(new Field("ARTISTS.ID")));
-               ArtistLoader artistLoader = new ArtistLoader();
-               database.process(query, artistLoader);
-               return artistLoader.get();
+               return database.getSingle(query, artistCreator);
+       }
+
+       public Collection<Artist> getArtistsByGroup(String groupId) throws DatabaseException {
+               Query query = new Query(Type.SELECT, "ARTISTS");
+               query.addField(new Field("ARTISTS.*"));
+               query.addJoin(new Join(JoinType.INNER, "GROUP_ARTISTS", new Field("ARTISTS.ID"), new Field("GROUP_ARTISTS.ARTIST")));
+               query.addWhereClause(new ValueFieldWhereClause(new ValueField("GROUP_ARTISTS.GROUP_", new StringParameter(groupId))));
+               return database.getMultiple(query, artistCreator);
        }
 
        public Track trackById(String id) throws DatabaseException {
@@ -123,7 +122,7 @@ public class DataManager {
                query.addField(new Field("GROUPS.*"));
                query.addJoin(new Join(JoinType.INNER, "GROUP_ARTISTS", new Field("GROUPS.ID"), new Field("GROUP_ARTISTS.GROUP_")));
                query.addWhereClause(new ValueFieldWhereClause(new ValueField("GROUP_ARTISTS.ARTIST", new StringParameter(artistId))));
-               return database.getMultiple(query, DefaultGroup.CREATOR);
+               return database.getMultiple(query, groupCreator);
        }
 
        private class TrackLoader implements ResultProcessor {
@@ -234,4 +233,110 @@ public class DataManager {
 
        }
 
+       private class ArtistCreator implements ObjectCreator<Artist> {
+
+               /**
+                * {@inheritDoc}
+                */
+               @Override
+               public Artist createObject(ResultSet resultSet) throws SQLException {
+                       return new LazyArtist(resultSet.getString("ARTISTS.ID")).name(resultSet.getString("ARTISTS.NAME"));
+               }
+
+       }
+
+       private class LazyGroup extends DefaultGroup {
+
+               private final Memoizer<Void> artistsMemoizer = new Memoizer<Void>(new Callable<Void>() {
+
+                       @Override
+                       public Void call() throws Exception {
+                               if (!hasValue("artists")) {
+                                       value("artists", Collection.class).set(getArtistsByGroup(id()));
+                               }
+                               return null;
+                       }
+
+               });
+
+               public LazyGroup(String id) {
+                       super(id);
+               }
+
+               /**
+                * {@inheritDoc}
+                */
+               @Override
+               public Collection<Artist> artists() {
+                       artistsMemoizer.get();
+                       return super.artists();
+               }
+
+       }
+
+       private class GroupCreator implements ObjectCreator<Group> {
+
+               /**
+                * {@inheritDoc}
+                */
+               @Override
+               public Group createObject(ResultSet resultSet) throws SQLException {
+                       return new LazyGroup(resultSet.getString("GROUPS.ID")).name(resultSet.getString("GROUPS.NAME")).url(resultSet.getString("GROUPS.URL"));
+               }
+
+       }
+
+       private class LazyTrack extends DefaultTrack {
+
+               private final Memoizer<Void> artistsMemoizer = new Memoizer<Void>(new Callable<Void>() {
+
+                       @Override
+                       public Void call() throws Exception {
+                               if (!hasValue("artists")) {
+                                       value("artists", List.class).set(getArtistsByTrack(id()));
+                               }
+                               return null;
+                       }
+
+               });
+
+               /**
+                * @param id
+                */
+               public LazyTrack(String id) {
+                       super(id);
+               }
+
+               /**
+                * {@inheritDoc}
+                */
+               @Override
+               public List<Artist> artists() {
+                       artistsMemoizer.get();
+                       return super.artists();
+               }
+
+               /**
+                * {@inheritDoc}
+                */
+               @Override
+               public Collection<Style> styles() {
+                       // TODO Auto-generated method stub
+                       return super.styles();
+               }
+
+       }
+
+       private class TrackCreator implements ObjectCreator<Track> {
+
+               /**
+                * {@inheritDoc}
+                */
+               @Override
+               public Track createObject(ResultSet resultSet) throws SQLException {
+                       return new LazyTrack(resultSet.getString("TRACKS.ID")).name(resultSet.getString("TRACKS.NAME"));
+               }
+
+       }
+
 }