data/splittable/SingleGridFactory_GeoTiff.java

package appl.parallel.data.splittable;

import java.io.File;

import schmitzm.data.WritableGridArray;
import appl.data.DataProxy;
import appl.data.WritableGridLLProxy;
import edu.bonn.xulu.appl.XuluRegistry;
import edu.bonn.xulu.io.AbstractFactory;
import edu.bonn.xulu.io.ExportFactory;
import edu.bonn.xulu.io.ImportFactory;
import edu.bonn.xulu.plugin.data.grid.SingleGrid;
import edu.bonn.xulu.plugin.io.grid.array.WritableGridArrayFactory_GeoTiff;

/**
 * Diese Factory importiert und exportiert Instanzen des Datentyps
 * {@link SingleGrid} aus/in das GeoTiff-Format.
 * Beim Import liefert die Factory ein auf Standard-Arrays basierendes Raster
 * ({@link WritableGridArray}).
 *
 * @author Dominik Appl
 * @author <a href="mailto:[email protected]">Martin Schmitz</a> (University of Bonn/Germany)
 * @version 1.0
 */
public class SingleGridFactory_GeoTiff extends AbstractFactory implements ImportFactory, ExportFactory {
  private static final WritableGridArrayFactory_GeoTiff GRID_FAC = new WritableGridArrayFactory_GeoTiff();
  private static final WritableGridArrayFactory_GeoTiff importFac = new WritableGridArrayFactory_GeoTiff();

  ////////////////////////////////////////////////////////////////////////
  ///////////////     Implementierung von ImportFactory     //////////////
  ////////////////////////////////////////////////////////////////////////
  /**
   * Liefert den Datentyp, den die Factory erzeugt.
   * @return immer {@link SingleGrid SingleGrid.class}
   */
  public Class getImportType() {
    return SingleGrid.class;
  }

  /**
   * Liefert den Datentyp, den die Factory als Import-Quelle benoetigt.
   * @return immer {@link File File.class}
   */
  public Class getImportSourceType() {
    return File.class;
  }

  /**
   * Importiert eine Instanz von {@link SingleGrid} aus einer Datei im
   * GeoTiff-Format.
   * @param input Eingabe-Quelle (muss ein {@link File} sein!)
   * @param reg   Instanz der Xulu-Registry, ueber die eine Factory ermittelt
   *              wird, die eine Standard-Instanz von {@link SingleGrid} erzeugt, in
   *              die das Raster importiert wird
   * @exception UnsupportedOperationException falls als Eingabe-Quelle keine
   *            Datei angegeben wird
   */
  public SingleGrid importObject(Object input, XuluRegistry reg) throws Exception {
          throw new UnsupportedOperationException("currently this import type is not supported for Proxy Grids. Use the standard data type");
//    AbstractFactory.checkImportSourceObject(this,input,getImportSourceType(),true);
//    // Aus Registry die passende Factory fuer SingleGrid suchen
//    InstantiationFactory instFac = AbstractFactory.getInstantiationFactoryFromRegistry(reg,getImportType(),true);
//    // Raster importieren und in ein SingleGrid einfuegen
//    SingleGrid sg = (SingleGrid)instFac.newInstance(false);
//    //new WritableGridLLProxy(importFac, new FileInputStream((File)input),reg)
//    ;
//    // Dateinamen in die Bezeichnung aufnehmen
//    sg.setDescription(sg.getDescription().concat(" [").concat(((File)input).getName()).concat("]"));

  }

  ////////////////////////////////////////////////////////////////////////
  ///////////////     Implementierung von ExportFactory     //////////////
  ////////////////////////////////////////////////////////////////////////
  /**
   * Prueft, ob ein Objekt exportiert werden kann. Dies ist der
   * Fall, wenn es sich um ein {@link SingleGrid} handelt, das ein
   * {@link WritableGridLLProxy} in seiner Raster-Eigenschaft besitzt.
   * @param obj zu pruefendes Objekt
   */
  public boolean isExportable(Object obj) {
    return obj!=null &&
           obj instanceof SingleGrid &&
           ((SingleGrid)obj).getGrid() instanceof SplittableLLProxyGrid;
  }

  /**
   * Prueft, ob ein Objekttyp exportiert werden kann. Dies ist der
   * Fall, wenn es sich um {@link SingleGrid} (oder eine Unterklasse)
   * handelt.
   * @param c zu pruefender Objekttyp
   */
  public boolean isExportable(Class c) {
    return SingleGrid.class.isAssignableFrom(c);
  }

  /**
   * Liefert den Objekt-Typ, den die Factory als Ziel zum Exportieren
   * benoetigt.
   * @return immer {@link File File.class}
   */
  public Class getExportDestinationType() {
    return File.class;
  }

  /**
   * Exportiert eine Instanz von {@link SingleGrid} in eine GeoTiff-Datei.
   * @param grid zu exportiertendes Raster (muss ein {@link SingleGrid} sein
   * @param output Export-Ziel (muss ein {@link File} sein!)
   * @exception UnsupportedOperationException falls als Export-Ziel keine
   *            Datei angegeben wird
   * @exception IllegalArgumentException falls es sich bei dem angegeben Raster
   *            nicht um ein {@link SingleGrid} handelt
   */
  public void exportObject(Object grid, Object output) throws Exception {
    AbstractFactory.checkExportDestinationObject(this,output,getExportDestinationType(),true);
    if ( !isExportable(grid) )
      throw new IllegalArgumentException(getClass().getName().concat(" can not export instances of ").concat(grid.getClass().getName()));
    GRID_FAC.exportObject( ((DataProxy)((SingleGrid)grid).getGrid()).getProxiedObject(), (File)output );
  }

}
1	mojays	2	package appl.parallel.data.splittable;
2
3			import java.io.File;
4
5	alfonx	78	import schmitzm.data.WritableGridArray;
6	mojays	2	import appl.data.DataProxy;
7	alfonx	78	import appl.data.WritableGridLLProxy;
8			import edu.bonn.xulu.appl.XuluRegistry;
9			import edu.bonn.xulu.io.AbstractFactory;
10			import edu.bonn.xulu.io.ExportFactory;
11	mojays	2	import edu.bonn.xulu.io.ImportFactory;
12			import edu.bonn.xulu.plugin.data.grid.SingleGrid;
13			import edu.bonn.xulu.plugin.io.grid.array.WritableGridArrayFactory_GeoTiff;
14
15			/**
16			* Diese Factory importiert und exportiert Instanzen des Datentyps
17			* {@link SingleGrid} aus/in das GeoTiff-Format.
18			* Beim Import liefert die Factory ein auf Standard-Arrays basierendes Raster
19			* ({@link WritableGridArray}).
20			*
21			* @author Dominik Appl
22			* @author <a href="mailto:[email protected]">Martin Schmitz</a> (University of Bonn/Germany)
23			* @version 1.0
24			*/
25			public class SingleGridFactory_GeoTiff extends AbstractFactory implements ImportFactory, ExportFactory {
26			private static final WritableGridArrayFactory_GeoTiff GRID_FAC = new WritableGridArrayFactory_GeoTiff();
27			private static final WritableGridArrayFactory_GeoTiff importFac = new WritableGridArrayFactory_GeoTiff();
28
29			////////////////////////////////////////////////////////////////////////
30			/////////////// Implementierung von ImportFactory //////////////
31			////////////////////////////////////////////////////////////////////////
32			/**
33			* Liefert den Datentyp, den die Factory erzeugt.
34			* @return immer {@link SingleGrid SingleGrid.class}
35			*/
36			public Class getImportType() {
37			return SingleGrid.class;
38			}
39
40			/**
41			* Liefert den Datentyp, den die Factory als Import-Quelle benoetigt.
42			* @return immer {@link File File.class}
43			*/
44			public Class getImportSourceType() {
45			return File.class;
46			}
47
48			/**
49			* Importiert eine Instanz von {@link SingleGrid} aus einer Datei im
50			* GeoTiff-Format.
51			* @param input Eingabe-Quelle (muss ein {@link File} sein!)
52			* @param reg Instanz der Xulu-Registry, ueber die eine Factory ermittelt
53			* wird, die eine Standard-Instanz von {@link SingleGrid} erzeugt, in
54			* die das Raster importiert wird
55			* @exception UnsupportedOperationException falls als Eingabe-Quelle keine
56			* Datei angegeben wird
57			*/
58			public SingleGrid importObject(Object input, XuluRegistry reg) throws Exception {
59			throw new UnsupportedOperationException("currently this import type is not supported for Proxy Grids. Use the standard data type");
60			// AbstractFactory.checkImportSourceObject(this,input,getImportSourceType(),true);
61			// // Aus Registry die passende Factory fuer SingleGrid suchen
62			// InstantiationFactory instFac = AbstractFactory.getInstantiationFactoryFromRegistry(reg,getImportType(),true);
63			// // Raster importieren und in ein SingleGrid einfuegen
64			// SingleGrid sg = (SingleGrid)instFac.newInstance(false);
65			// //new WritableGridLLProxy(importFac, new FileInputStream((File)input),reg)
66			// ;
67			// // Dateinamen in die Bezeichnung aufnehmen
68			// sg.setDescription(sg.getDescription().concat(" [").concat(((File)input).getName()).concat("]"));
69
70			}
71
72			////////////////////////////////////////////////////////////////////////
73			/////////////// Implementierung von ExportFactory //////////////
74			////////////////////////////////////////////////////////////////////////
75			/**
76			* Prueft, ob ein Objekt exportiert werden kann. Dies ist der
77			* Fall, wenn es sich um ein {@link SingleGrid} handelt, das ein
78			* {@link WritableGridLLProxy} in seiner Raster-Eigenschaft besitzt.
79			* @param obj zu pruefendes Objekt
80			*/
81			public boolean isExportable(Object obj) {
82			return obj!=null &&
83			obj instanceof SingleGrid &&
84			((SingleGrid)obj).getGrid() instanceof SplittableLLProxyGrid;
85			}
86
87			/**
88			* Prueft, ob ein Objekttyp exportiert werden kann. Dies ist der
89			* Fall, wenn es sich um {@link SingleGrid} (oder eine Unterklasse)
90			* handelt.
91			* @param c zu pruefender Objekttyp
92			*/
93			public boolean isExportable(Class c) {
94			return SingleGrid.class.isAssignableFrom(c);
95			}
96
97			/**
98			* Liefert den Objekt-Typ, den die Factory als Ziel zum Exportieren
99			* benoetigt.
100			* @return immer {@link File File.class}
101			*/
102			public Class getExportDestinationType() {
103			return File.class;
104			}
105
106			/**
107			* Exportiert eine Instanz von {@link SingleGrid} in eine GeoTiff-Datei.
108			* @param grid zu exportiertendes Raster (muss ein {@link SingleGrid} sein
109			* @param output Export-Ziel (muss ein {@link File} sein!)
110			* @exception UnsupportedOperationException falls als Export-Ziel keine
111			* Datei angegeben wird
112			* @exception IllegalArgumentException falls es sich bei dem angegeben Raster
113			* nicht um ein {@link SingleGrid} handelt
114			*/
115			public void exportObject(Object grid, Object output) throws Exception {
116			AbstractFactory.checkExportDestinationObject(this,output,getExportDestinationType(),true);
117			if ( !isExportable(grid) )
118			throw new IllegalArgumentException(getClass().getName().concat(" can not export instances of ").concat(grid.getClass().getName()));
119			GRID_FAC.exportObject( ((DataProxy)((SingleGrid)grid).getGrid()).getProxiedObject(), (File)output );
120			}
121
122			}