DefinitionCreationFactory.java :  » Math » migen » uk » ac » lkl » common » util » database » Java Open Source

package uk.ac.lkl.common.util.database;

import java.util.HashMap;

import uk.ac.lkl.common.util.database.constraint.ForeignKey;
import uk.ac.lkl.common.util.database.constraint.ForeignKeyList;
import uk.ac.lkl.common.util.database.constraint.PrimaryKey;
import uk.ac.lkl.common.util.database.io.ColumnDefinitionReader;
import uk.ac.lkl.common.util.database.io.DatabaseDefinitionReader;
import uk.ac.lkl.common.util.database.io.DefinitionReader;
import uk.ac.lkl.common.util.database.io.TableDefinitionReader;

public class DefinitionCreationFactory {

    private static HashMap<Class<? extends Definition>, DefinitionReader<?>> DEFINITION_READER_MAP;

    private static HashMap<Class<? extends Definition>, DefinitionCreator<?>> DEFINITION_CREATOR_MAP;

    static {
  initialiseDefinitionReaderMap();
  initialiseDefinitionCreatorMap();
    }

    private static void initialiseDefinitionReaderMap() {
  DEFINITION_READER_MAP = new HashMap<Class<? extends Definition>, DefinitionReader<?>>();
  DEFINITION_READER_MAP.put(DatabaseDefinition.class,
    new DatabaseDefinitionReader());
  DEFINITION_READER_MAP.put(TableDefinition.class,
    new TableDefinitionReader());
  DEFINITION_READER_MAP.put(ColumnDefinition.class,
    new ColumnDefinitionReader());
    }

    private static void initialiseDefinitionCreatorMap() {
  DEFINITION_CREATOR_MAP = new HashMap<Class<? extends Definition>, DefinitionCreator<?>>();
  for (Class<? extends Definition> definitionClass : DEFINITION_READER_MAP
    .keySet()) {
      updateDefinitionCreatorMap(definitionClass);
  }
    }

    // 'capture' method
    @SuppressWarnings("unchecked")
    private static <D extends Definition> void updateDefinitionCreatorMap(
      Class<D> definitionClass) {
  DefinitionReader<D> definitionReader = (DefinitionReader<D>) DEFINITION_READER_MAP
    .get(definitionClass);
  DefinitionCreator<D> definitionCreator = new DefinitionCreator<D>(
    definitionReader);
  DEFINITION_CREATOR_MAP.put(definitionClass, definitionCreator);
    }

    @SuppressWarnings("unchecked")
    private static <D extends Definition> DefinitionCreator<D> getDefinitionCreator(
      Class<D> definitionClass) {
  DefinitionCreator<D> definitionCreator = (DefinitionCreator<D>) DEFINITION_CREATOR_MAP
    .get(definitionClass);
  return definitionCreator;
    }

    public static DatabaseDefinition createDatabaseFromString(String string)
      throws DatabaseDefinitionException {
  return createFromString(DatabaseDefinition.class, string);
    }

    public static TableDefinition createTableFromString(String string)
      throws DatabaseDefinitionException {
  return createFromString(TableDefinition.class, string);
    }

    public static ColumnDefinition createColumnFromString(String string)
      throws DatabaseDefinitionException {
  return createFromString(ColumnDefinition.class, string);
    }

    public static ForeignKeyList createForeignKeyListFromString(String string)
      throws DatabaseDefinitionException {
  return createFromString(ForeignKeyList.class, string);
    }

    public static ForeignKey createForeignKeyFromString(String string)
      throws DatabaseDefinitionException {
  return createFromString(ForeignKey.class, string);
    }

    public static PrimaryKey createPrimaryKeyFromString(String string)
      throws DatabaseDefinitionException {
  return createFromString(PrimaryKey.class, string);
    }

    public static <D extends Definition> D createFromString(
      Class<D> definitionClass, String string)
      throws DatabaseDefinitionException {
  return getDefinitionCreator(definitionClass).createFromString(string);
    }

    public static DatabaseDefinition createDatabaseFromFile(String path)
      throws DatabaseDefinitionException {
  return createFromFile(DatabaseDefinition.class, path);
    }

    public static TableDefinition createTableFromFile(String path)
      throws DatabaseDefinitionException {
  return createFromFile(TableDefinition.class, path);
    }

    public static ColumnDefinition createColumnFromFile(String path)
      throws DatabaseDefinitionException {
  return createFromFile(ColumnDefinition.class, path);
    }

    public static PrimaryKey createPrimaryKeyFromFile(String path)
      throws DatabaseDefinitionException {
  return createFromFile(PrimaryKey.class, path);
    }

    public static ForeignKeyList createForeignKeyListFromFile(String path)
      throws DatabaseDefinitionException {
  return createFromFile(ForeignKeyList.class, path);
    }

    public static ForeignKey createForeignKeyFromFile(String path)
      throws DatabaseDefinitionException {
  return createFromFile(ForeignKey.class, path);
    }

    public static <D extends Definition> D createFromFile(
      Class<D> definitionClass, String path)
      throws DatabaseDefinitionException {
  return getDefinitionCreator(definitionClass).createFromFile(path);
    }

    public static DatabaseDefinition createDatabaseFromFile(Object object,
      String path) throws DatabaseDefinitionException {
  return createFromFile(DatabaseDefinition.class, object, path);
    }

    public static TableDefinition createTableFromFile(Object object, String path)
      throws DatabaseDefinitionException {
  return createFromFile(TableDefinition.class, object, path);
    }

    public static ColumnDefinition createColumnFromFile(Object object,
      String path) throws DatabaseDefinitionException {
  return createFromFile(ColumnDefinition.class, object, path);
    }

    public static PrimaryKey createPrimaryKeyFromFile(Object object, String path)
      throws DatabaseDefinitionException {
  return createFromFile(PrimaryKey.class, object, path);
    }

    public static ForeignKeyList createForeignKeyListFromFile(Object object,
      String path) throws DatabaseDefinitionException {
  return createFromFile(ForeignKeyList.class, object, path);
    }

    public static ForeignKey createForeignKeyFromFile(Object object, String path)
      throws DatabaseDefinitionException {
  return createFromFile(ForeignKey.class, object, path);
    }

    public static <D extends Definition> D createFromFile(
      Class<D> definitionClass, Object object, String path)
      throws DatabaseDefinitionException {
  return getDefinitionCreator(definitionClass).createFromFile(object,
    path);
    }

    public static DatabaseDefinition createDatabaseFromSource(
      DefinitionSource source) throws DatabaseDefinitionException {
  return createFromSource(DatabaseDefinition.class, source);
    }

    public static TableDefinition createTableFromSource(DefinitionSource source)
      throws DatabaseDefinitionException {
  return createFromSource(TableDefinition.class, source);
    }

    public static ColumnDefinition createColumnFromSource(
      DefinitionSource source) throws DatabaseDefinitionException {
  return createFromSource(ColumnDefinition.class, source);
    }

    public static PrimaryKey createPrimaryKeyFromSource(DefinitionSource source)
      throws DatabaseDefinitionException {
  return createFromSource(PrimaryKey.class, source);
    }

    public static ForeignKeyList createForeignKeyListFromSource(
      DefinitionSource source) throws DatabaseDefinitionException {
  return createFromSource(ForeignKeyList.class, source);
    }

    public static ForeignKey createForeignKeyFromSource(DefinitionSource source)
      throws DatabaseDefinitionException {
  return createFromSource(ForeignKey.class, source);
    }

    public static <D extends Definition> D createFromSource(
      Class<D> definitionClass, DefinitionSource source)
      throws DatabaseDefinitionException {
  return getDefinitionCreator(definitionClass).createFromSource(source);
    }

}