data/splittable/SingleGridFactory_GeoTiff.java

package appl.parallel.data.splittable;

import java.io.File;

import appl.data.DataProxy;


import schmitzm.data.WritableGridArray;

import edu.bonn.xulu.io.ImportFactory;
import edu.bonn.xulu.io.InstantiationFactory;
import edu.bonn.xulu.io.ExportFactory;
import edu.bonn.xulu.io.AbstractFactory;
import edu.bonn.xulu.appl.XuluRegistry;

import edu.bonn.xulu.plugin.data.grid.SingleGrid;
import edu.bonn.xulu.plugin.io.grid.array.WritableGridArrayFactory_GeoTiff;

// nur fuer Doku
import appl.data.WritableGridLLProxy;

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