Changeset 6531


Ignore:
Timestamp:
06/17/10 07:13:30 (9 years ago)
Author:
callan
Message:

Re-run of code generation; working copy schema. Huge merge. (See  ome-xml:r635)

Location:
trunk/components
Files:
8 added
1 deleted
175 edited

Legend:

Unmodified
Added
Removed
  • trunk/components/bio-formats/src/loci/formats/FormatWriter.java

    r6294 r6531  
    2727import java.io.IOException; 
    2828import java.util.HashMap; 
     29 
     30import ome.xml.model.primitives.PositiveInteger; 
    2931 
    3032import loci.common.DataTools; 
     
    342344      FormatTools.pixelTypeFromString(r.getPixelsType(series).toString()); 
    343345    int bpp = FormatTools.getBytesPerPixel(pixelType); 
    344     Integer samples = r.getChannelSamplesPerPixel(series, 0); 
    345     if (samples == null) samples = 1; 
    346     int minSize = bpp * w * h * samples; 
     346    PositiveInteger samples = r.getChannelSamplesPerPixel(series, 0); 
     347    if (samples == null) samples = new PositiveInteger(1); 
     348    int minSize = bpp * w * h * samples.getValue(); 
    347349    if (buf.length < minSize) { 
    348350      throw new FormatException("Buffer is too small; expected " + minSize + 
     
    392394  protected int getSamplesPerPixel() { 
    393395    MetadataRetrieve r = getMetadataRetrieve(); 
    394     Integer samples = r.getChannelSamplesPerPixel(series, 0); 
     396    PositiveInteger samples = r.getChannelSamplesPerPixel(series, 0); 
    395397    if (samples == null) { 
    396398      LOGGER.warn("SamplesPerPixel #0 is null. It is assumed to be 1."); 
    397399    } 
    398     return samples == null ? 1 : samples.intValue(); 
     400    return samples == null ? 1 : samples.getValue(); 
    399401  } 
    400402 
  • trunk/components/bio-formats/src/loci/formats/MetadataTools.java

    r6492 r6531  
    4141import ome.xml.model.enums.EnumerationException; 
    4242import ome.xml.model.enums.PixelType; 
     43import ome.xml.model.primitives.NonNegativeInteger; 
    4344import ome.xml.model.primitives.PositiveInteger; 
    4445 
     
    129130        for (int c=0; c<r.getEffectiveSizeC(); c++) { 
    130131          store.setChannelID(createLSID("Channel", i, c), i, c); 
    131           store.setChannelSamplesPerPixel(sampleCount, i, c); 
     132          store.setChannelSamplesPerPixel(new PositiveInteger(sampleCount), i, c); 
    132133        } 
    133134      } 
     
    135136        for (int q=0; q<r.getImageCount(); q++) { 
    136137          int[] coords = r.getZCTCoords(q); 
    137           store.setPlaneTheZ(new Integer(coords[0]), i, q); 
    138           store.setPlaneTheC(new Integer(coords[1]), i, q); 
    139           store.setPlaneTheT(new Integer(coords[2]), i, q); 
     138          store.setPlaneTheZ(new NonNegativeInteger(coords[0]), i, q); 
     139          store.setPlaneTheC(new NonNegativeInteger(coords[1]), i, q); 
     140          store.setPlaneTheT(new NonNegativeInteger(coords[2]), i, q); 
    140141        } 
    141142      } 
  • trunk/components/bio-formats/src/loci/formats/gui/AWTImageTools.java

    r6309 r6531  
    6767import loci.formats.meta.MetadataRetrieve; 
    6868 
     69import ome.xml.model.primitives.PositiveInteger; 
     70 
    6971import org.slf4j.Logger; 
    7072import org.slf4j.LoggerFactory; 
     
    439441    String pixelType = meta.getPixelsType(series).toString(); 
    440442    int type = FormatTools.pixelTypeFromString(pixelType); 
    441     Integer nChannels = meta.getChannelSamplesPerPixel(series, 0); 
     443    PositiveInteger nChannels = meta.getChannelSamplesPerPixel(series, 0); 
    442444    if (nChannels == null) { 
    443445      LOGGER.warn("SamplesPerPixel is null; it is assumed to be 1."); 
    444446    } 
    445     int channels = nChannels == null ? 1 : nChannels.intValue(); 
     447    int channels = nChannels == null ? 1 : nChannels.getValue(); 
    446448    boolean littleEndian = 
    447449      !meta.getPixelsBinDataBigEndian(series, 0).booleanValue(); 
  • trunk/components/bio-formats/src/loci/formats/in/BDReader.java

    r6458 r6531  
    305305        } 
    306306 
    307         store.setObjectiveNominalMagnification(new Integer(mag), 0, 0); 
     307        store.setObjectiveNominalMagnification(PositiveInteger.valueOf(mag), 0, 0); 
    308308        if (na != null) { 
    309309          na = na.substring(0, 1) + "." + na.substring(1); 
  • trunk/components/bio-formats/src/loci/formats/in/BioRadReader.java

    r6495 r6531  
    4040import loci.formats.meta.IMinMaxStore; 
    4141import loci.formats.meta.MetadataStore; 
     42 
     43import ome.xml.model.primitives.PositiveInteger; 
    4244 
    4345import org.xml.sax.Attributes; 
     
    486488 
    487489      store.setObjectiveLensNA(new Double(lens), 0, 0); 
    488       store.setObjectiveNominalMagnification((int) magFactor, 0, 0); 
     490      store.setObjectiveNominalMagnification( 
     491          new PositiveInteger((int) magFactor), 0, 0); 
    489492      store.setObjectiveCorrection(getCorrection("Other"), 0, 0); 
    490493      store.setObjectiveImmersion(getImmersion("Other"), 0, 0); 
     
    632635              else if (key.equals("INFO_OBJECTIVE_MAGNIFICATION")) { 
    633636                store.setObjectiveNominalMagnification( 
    634                   (int) Float.parseFloat(value), 0, 0); 
     637                  new PositiveInteger((int) Float.parseFloat(value)), 0, 0); 
    635638              } 
    636639              else if (key.equals("LENS_MAGNIFICATION")) { 
    637640                store.setObjectiveNominalMagnification( 
    638                   (int) Float.parseFloat(value), 0, 0); 
     641                  new PositiveInteger((int) Float.parseFloat(value)), 0, 0); 
    639642              } 
    640643              else if (key.startsWith("SETTING")) { 
     
    720723 
    721724                  store.setObjectiveNominalMagnification( 
    722                     (int) Float.parseFloat(values[11]), 0, 0); 
     725                    new PositiveInteger((int) Float.parseFloat(values[11])), 0, 0); 
    723726                  store.setPixelsPhysicalSizeZ(new Double(values[14]), 0); 
    724727                  break; 
  • trunk/components/bio-formats/src/loci/formats/in/DeltavisionReader.java

    r6495 r6531  
    805805            try { 
    806806              store.setObjectiveNominalMagnification( 
    807                 new Integer(magnification), 0, 0); 
     807                PositiveInteger.valueOf(magnification), 0, 0); 
    808808            } 
    809809            catch (NumberFormatException e) { 
  • trunk/components/bio-formats/src/loci/formats/in/FV1000Reader.java

    r6503 r6531  
    5353import loci.formats.tiff.TiffParser; 
    5454 
     55import ome.xml.model.primitives.NonNegativeInteger; 
    5556import ome.xml.model.primitives.PositiveInteger; 
    5657 
     
    918919          try { 
    919920            store.setTransmittanceRangeCutIn( 
    920               new Integer(emValues[0]), 0, channelIndex); 
     921              PositiveInteger.valueOf(emValues[0]), 0, channelIndex); 
    921922            store.setTransmittanceRangeCutOut( 
    922               new Integer(emValues[1]), 0, channelIndex); 
     923              PositiveInteger.valueOf(emValues[1]), 0, channelIndex); 
    923924          } 
    924925          catch (NumberFormatException e) { } 
     
    961962    if (magnification != null) { 
    962963      int mag = (int) Float.parseFloat(magnification); 
    963       store.setObjectiveNominalMagnification(mag, 0, 0); 
     964      store.setObjectiveNominalMagnification(new PositiveInteger(mag), 0, 0); 
    964965    } 
    965966    if (workingDistance != null) { 
     
    10461047 
    10471048          if (shapeType == POINT) { 
    1048             store.setPointTheZ(zIndex, nextROI, shape); 
    1049             store.setPointTheT(tIndex, nextROI, shape); 
    1050             store.setPointFontSize(fontSize, nextROI, shape); 
     1049            store.setPointTheZ(new NonNegativeInteger(zIndex), nextROI, shape); 
     1050            store.setPointTheT(new NonNegativeInteger(tIndex), nextROI, shape); 
     1051            store.setPointFontSize(new NonNegativeInteger(fontSize), nextROI, shape); 
    10511052            store.setPointStrokeWidth(new Double(lineWidth), nextROI, shape); 
    10521053 
     
    10681069                store.setRectangleHeight(new Double(height), nextROI, shape); 
    10691070 
    1070                 store.setRectangleTheZ(zIndex, nextROI, shape); 
    1071                 store.setRectangleTheT(tIndex, nextROI, shape); 
    1072                 store.setRectangleFontSize(fontSize, nextROI, shape); 
     1071                store.setRectangleTheZ(new NonNegativeInteger(zIndex), nextROI, shape); 
     1072                store.setRectangleTheT(new NonNegativeInteger(tIndex), nextROI, shape); 
     1073                store.setRectangleFontSize(new NonNegativeInteger(fontSize), nextROI, shape); 
    10731074                store.setRectangleStrokeWidth( 
    10741075                  new Double(lineWidth), nextROI, shape); 
     
    10901091            store.setLineY2(new Double(y + height), nextROI, shape); 
    10911092 
    1092             store.setLineTheZ(zIndex, nextROI, shape); 
    1093             store.setLineTheT(tIndex, nextROI, shape); 
    1094             store.setLineFontSize(fontSize, nextROI, shape); 
     1093            store.setLineTheZ(new NonNegativeInteger(zIndex), nextROI, shape); 
     1094            store.setLineTheT(new NonNegativeInteger(tIndex), nextROI, shape); 
     1095            store.setLineFontSize(new NonNegativeInteger(fontSize), nextROI, shape); 
    10951096            store.setLineStrokeWidth(new Double(lineWidth), nextROI, shape); 
    10961097 
     
    11091110            store.setEllipseRadiusY(ry, nextROI, shape); 
    11101111 
    1111             store.setEllipseTheZ(zIndex, nextROI, shape); 
    1112             store.setEllipseTheT(tIndex, nextROI, shape); 
    1113             store.setEllipseFontSize(fontSize, nextROI, shape); 
     1112            store.setEllipseTheZ( 
     1113                new NonNegativeInteger(zIndex), nextROI, shape); 
     1114            store.setEllipseTheT( 
     1115                new NonNegativeInteger(tIndex), nextROI, shape); 
     1116            store.setEllipseFontSize( 
     1117                new NonNegativeInteger(fontSize), nextROI, shape); 
    11141118            store.setEllipseStrokeWidth(new Double(lineWidth), nextROI, shape); 
    11151119            store.setEllipseTransform(String.format(ROTATION, 
     
    11301134            store.setPolylineClosed( 
    11311135              shapeType == POLYGON || shapeType == FREE_SHAPE, nextROI, shape); 
    1132             store.setPolylineTheZ(zIndex, nextROI, shape); 
    1133             store.setPolylineTheT(tIndex, nextROI, shape); 
    1134             store.setPolylineFontSize(fontSize, nextROI, shape); 
     1136            store.setPolylineTheZ( 
     1137                new NonNegativeInteger(zIndex), nextROI, shape); 
     1138            store.setPolylineTheT( 
     1139                new NonNegativeInteger(tIndex), nextROI, shape); 
     1140            store.setPolylineFontSize( 
     1141                new NonNegativeInteger(fontSize), nextROI, shape); 
    11351142            store.setPolylineStrokeWidth(new Double(lineWidth), nextROI, shape); 
    11361143          } 
  • trunk/components/bio-formats/src/loci/formats/in/InCellReader.java

    r6495 r6531  
    737737      } 
    738738      else if (qName.equals("ObjectiveCalibration")) { 
    739         store.setObjectiveNominalMagnification((int) 
    740           Double.parseDouble(attributes.getValue("magnification")), 0, 0); 
     739        store.setObjectiveNominalMagnification(new PositiveInteger((int) 
     740          Double.parseDouble(attributes.getValue("magnification"))), 0, 0); 
    741741        store.setObjectiveLensNA(new Double( 
    742742          attributes.getValue("numerical_aperture")), 0, 0); 
  • trunk/components/bio-formats/src/loci/formats/in/IvisionReader.java

    r6495 r6531  
    3434import loci.formats.MetadataTools; 
    3535import loci.formats.meta.MetadataStore; 
     36 
     37import ome.xml.model.primitives.PositiveInteger; 
    3638 
    3739import org.xml.sax.Attributes; 
     
    262264      if (lensNA != null) store.setObjectiveLensNA(lensNA, 0, 0); 
    263265      if (magnification != null) { 
    264         store.setObjectiveNominalMagnification(magnification, 0, 0); 
     266        store.setObjectiveNominalMagnification( 
     267            new PositiveInteger(magnification), 0, 0); 
    265268      } 
    266269      if (refractiveIndex != null) { 
  • trunk/components/bio-formats/src/loci/formats/in/LeicaHandler.java

    r6526 r6531  
    4949import ome.xml.model.enums.handlers.LaserTypeEnumHandler; 
    5050import ome.xml.model.enums.handlers.MicroscopeTypeEnumHandler; 
     51import ome.xml.model.primitives.NonNegativeInteger; 
    5152import ome.xml.model.primitives.PercentFraction; 
    5253import ome.xml.model.primitives.PositiveInteger; 
     
    560561 
    561562            store.setObjectiveNominalMagnification( 
    562               new Integer(mag), numDatasets, 0); 
     563              new PositiveInteger(mag), numDatasets, 0); 
    563564            store.setObjectiveLensNA(new Double(na), numDatasets, 0); 
    564565          } 
     
    645646          store.setFilterModel(object, numDatasets, nextFilter); 
    646647          if (v != null) { 
    647             store.setTransmittanceRangeCutIn(v, numDatasets, nextFilter); 
     648            store.setTransmittanceRangeCutIn( 
     649                new PositiveInteger(v), numDatasets, nextFilter); 
    648650          } 
    649651        } 
    650652        else if (attributes.getValue("Description").endsWith("(right)")) { 
    651653          if (v != null) { 
    652             store.setTransmittanceRangeCutOut(v, numDatasets, nextFilter); 
     654            store.setTransmittanceRangeCutOut( 
     655                new PositiveInteger(v), numDatasets, nextFilter); 
    653656            nextFilter++; 
    654657          } 
     
    697700            MetadataTools.createLSID("Filter", numDatasets, nextFilter); 
    698701          store.setFilterID(filter, numDatasets, nextFilter); 
    699           store.setTransmittanceRangeCutIn(m.cutIn, numDatasets, nextFilter); 
    700           store.setTransmittanceRangeCutOut(m.cutOut, numDatasets, nextFilter); 
     702          store.setTransmittanceRangeCutIn( 
     703              new PositiveInteger(m.cutIn), numDatasets, nextFilter); 
     704          store.setTransmittanceRangeCutOut( 
     705              new PositiveInteger(m.cutOut), numDatasets, nextFilter); 
    701706          store.setLightPathEmissionFilterRef( 
    702707            filter, numDatasets, nextChannel, 0); 
     
    916921      if (text != null) store.setTextValue(text, roi, 0); 
    917922      if (fontSize != null) { 
    918         store.setTextFontSize((int) Double.parseDouble(fontSize), roi, 0); 
     923        store.setTextFontSize( 
     924            new NonNegativeInteger((int) Double.parseDouble(fontSize)), roi, 0); 
    919925      } 
    920926      store.setTextStrokeWidth(new Double(linewidth), roi, 0); 
  • trunk/components/bio-formats/src/loci/formats/in/LeicaReader.java

    r6495 r6531  
    12171217          store.setObjectiveModel(model.toString().trim(), series, objective); 
    12181218          store.setObjectiveLensNA(new Double(na), series, objective); 
    1219           store.setObjectiveNominalMagnification((int) 
    1220             Double.parseDouble(mag), series, objective); 
     1219          store.setObjectiveNominalMagnification(new PositiveInteger((int) 
     1220            Double.parseDouble(mag)), series, objective); 
    12211221        } 
    12221222        else if (tokens[2].equals("OrderNumber")) { 
     
    12551255 
    12561256            if (tokens[3].equals("0") && !cutInPopulated[series][index]) { 
    1257               store.setTransmittanceRangeCutIn(wavelength, series, channel); 
     1257              store.setTransmittanceRangeCutIn( 
     1258                  new PositiveInteger(wavelength), series, channel); 
    12581259              cutInPopulated[series][index] = true; 
    12591260            } 
    12601261            else if (tokens[3].equals("1") && !cutOutPopulated[series][index]) { 
    1261               store.setTransmittanceRangeCutOut(wavelength, series, channel); 
     1262              store.setTransmittanceRangeCutOut( 
     1263                  new PositiveInteger(wavelength), series, channel); 
    12621264              cutOutPopulated[series][index] = true; 
    12631265            } 
  • trunk/components/bio-formats/src/loci/formats/in/MIASReader.java

    r6458 r6531  
    5050 
    5151import ome.xml.model.primitives.NonNegativeInteger; 
     52import ome.xml.model.primitives.PositiveInteger; 
    5253 
    5354/** 
     
    844845    store.setImageROIRef(roiID, series, roi); 
    845846 
    846     store.setTextTheT(tv, roi, 0); 
    847     store.setTextTheZ(zv, roi, 0); 
     847    store.setTextTheT(new NonNegativeInteger(tv), roi, 0); 
     848    store.setTextTheZ(new NonNegativeInteger(zv), roi, 0); 
    848849    store.setTextValue(data[columns.indexOf("Label")], roi, 0); 
    849850 
    850     store.setEllipseTheT(tv, roi, 1); 
    851     store.setEllipseTheZ(zv, roi, 1); 
     851    store.setEllipseTheT(new NonNegativeInteger(tv), roi, 1); 
     852    store.setEllipseTheZ(new NonNegativeInteger(zv), roi, 1); 
    852853    store.setEllipseX(new Double(data[columns.indexOf("Col")]), roi, 1); 
    853854    store.setEllipseY(new Double(data[columns.indexOf("Row")]), roi, 1); 
     
    917918        } 
    918919        else if (key.equals("Magnification")) { 
    919           int mag = (int) Double.parseDouble(value); 
    920           store.setObjectiveNominalMagnification(mag, 0, 0); 
     920          store.setObjectiveNominalMagnification( 
     921              new PositiveInteger((int) Double.parseDouble(value)), 0, 0); 
    921922        } 
    922923        else if (key.startsWith("Mode_")) { 
  • trunk/components/bio-formats/src/loci/formats/in/NativeND2Reader.java

    r6458 r6531  
    4545import loci.formats.meta.MetadataStore; 
    4646 
     47import ome.xml.model.primitives.NonNegativeInteger; 
    4748import ome.xml.model.primitives.PositiveInteger; 
    4849 
     
    10801081 
    10811082      if (type.equals("Text")) { 
    1082         store.setTextFontSize(new Integer(roi.get("fHeight")), r, 0); 
     1083        store.setTextFontSize(NonNegativeInteger.valueOf(roi.get("fHeight")), r, 0); 
    10831084        store.setTextValue(roi.get("eval-text"), r, 0); 
    10841085        store.setTextStrokeWidth(new Double(roi.get("line-width")), r, 0); 
  • trunk/components/bio-formats/src/loci/formats/in/NikonTiffReader.java

    r6458 r6531  
    225225      store.setObjectiveID(objectiveID, 0, 0); 
    226226      store.setImageObjectiveSettingsID(objectiveID, 0); 
    227       store.setObjectiveNominalMagnification(magnification, 0, 0); 
     227      store.setObjectiveNominalMagnification( 
     228          new PositiveInteger(magnification), 0, 0); 
    228229 
    229230      if (correction == null) correction = "Other"; 
  • trunk/components/bio-formats/src/loci/formats/in/OMETiffReader.java

    r6494 r6531  
    3131import java.util.Iterator; 
    3232import java.util.Vector; 
     33 
     34import ome.xml.model.primitives.NonNegativeInteger; 
     35import ome.xml.model.primitives.PositiveInteger; 
    3336 
    3437import loci.common.Location; 
     
    362365      String order = meta.getPixelsDimensionOrder(i).toString(); 
    363366 
    364       Integer samplesPerPixel = null; 
     367      PositiveInteger samplesPerPixel = null; 
    365368      if (meta.getChannelCount(i) > 0) { 
    366369        samplesPerPixel = meta.getChannelSamplesPerPixel(i, 0); 
    367370      } 
    368       int samples = samplesPerPixel == null ?  -1 : samplesPerPixel.intValue(); 
     371      int samples = samplesPerPixel == null ?  -1 : samplesPerPixel.getValue(); 
    369372      int tiffSamples = firstIFD.getSamplesPerPixel(); 
    370373      if (samples != tiffSamples) { 
     
    402405          LOGGER.debug("Ignoring null UUID object when retrieving value."); 
    403406        } 
    404         Integer tdIFD = meta.getTiffDataIFD(i, td); 
    405         int ifd = tdIFD == null ? 0 : tdIFD.intValue(); 
    406         Integer numPlanes = meta.getTiffDataPlaneCount(i, td); 
    407         Integer firstC = meta.getTiffDataFirstC(i, td); 
    408         Integer firstT = meta.getTiffDataFirstT(i, td); 
    409         Integer firstZ = meta.getTiffDataFirstZ(i, td); 
    410         int c = firstC == null ? 0 : firstC.intValue(); 
    411         int t = firstT == null ? 0 : firstT.intValue(); 
    412         int z = firstZ == null ? 0 : firstZ.intValue(); 
     407        NonNegativeInteger tdIFD = meta.getTiffDataIFD(i, td); 
     408        int ifd = tdIFD == null ? 0 : tdIFD.getValue(); 
     409        NonNegativeInteger numPlanes = meta.getTiffDataPlaneCount(i, td); 
     410        NonNegativeInteger firstC = meta.getTiffDataFirstC(i, td); 
     411        NonNegativeInteger firstT = meta.getTiffDataFirstT(i, td); 
     412        NonNegativeInteger firstZ = meta.getTiffDataFirstZ(i, td); 
     413        int c = firstC == null ? 0 : firstC.getValue(); 
     414        int t = firstT == null ? 0 : firstT.getValue(); 
     415        int z = firstZ == null ? 0 : firstZ.getValue(); 
    413416 
    414417        // NB: some writers index FirstC, FirstZ and FirstT from 1 
     
    419422        int index = FormatTools.getIndex(order, 
    420423          sizeZ, effSizeC, sizeT, num, z, c, t); 
    421         int count = numPlanes == null ? 1 : numPlanes.intValue(); 
     424        int count = numPlanes == null ? 1 : numPlanes.getValue(); 
    422425        if (count == 0) { 
    423426          core[s] = null; 
  • trunk/components/bio-formats/src/loci/formats/in/ZeissLSMReader.java

    r6495 r6531  
    2828import java.util.Hashtable; 
    2929import java.util.Vector; 
     30 
     31import ome.xml.model.primitives.NonNegativeInteger; 
     32import ome.xml.model.primitives.PositiveInteger; 
    3033 
    3134import loci.common.DataTools; 
     
    928931        getCorrection(recording.correction), series, 0); 
    929932      store.setObjectiveImmersion(getImmersion(recording.immersion), series, 0); 
    930       store.setObjectiveNominalMagnification(recording.magnification, 
    931         series, 0); 
     933      store.setObjectiveNominalMagnification( 
     934          new PositiveInteger(recording.magnification), series, 0); 
    932935      store.setObjectiveLensNA(recording.lensNA, series, 0); 
    933936      store.setObjectiveIris(recording.iris, series, 0); 
     
    991994          String[] v = transmittance.split("-"); 
    992995          try { 
    993             store.setTransmittanceRangeCutIn(new Integer(v[0].trim()), series, 
    994               nextFilter); 
     996            store.setTransmittanceRangeCutIn( 
     997                PositiveInteger.valueOf(v[0].trim()), series, nextFilter); 
    995998          } 
    996999          catch (NumberFormatException e) { } 
    9971000          if (v.length > 1) { 
    9981001            try { 
    999               store.setTransmittanceRangeCutOut(new Integer(v[1].trim()), 
    1000                 series, nextFilter); 
     1002              store.setTransmittanceRangeCutOut( 
     1003                  PositiveInteger.valueOf(v[1].trim()), series, nextFilter); 
    10011004            } 
    10021005            catch (NumberFormatException e) { } 
     
    11001103          String text = DataTools.stripString(in.readCString()); 
    11011104          store.setTextValue(text, i, 0); 
    1102           store.setTextFontSize(fontHeight, i, 0); 
     1105          store.setTextFontSize(new NonNegativeInteger(fontHeight), i, 0); 
    11031106          store.setTextStrokeWidth(lineWidth, i, 0); 
    11041107          break; 
     
    11141117          store.setLineX2(endX, i, 0); 
    11151118          store.setLineY2(endY, i, 0); 
    1116           store.setLineFontSize(fontHeight, i, 0); 
     1119          store.setLineFontSize(new NonNegativeInteger(fontHeight), i, 0); 
    11171120          store.setLineStrokeWidth(lineWidth, i, 0); 
    11181121          break; 
     
    11391142          store.setRectangleWidth(width, i, 0); 
    11401143          store.setRectangleHeight(height, i, 0); 
    1141           store.setRectangleFontSize(fontHeight, i, 0); 
     1144          store.setRectangleFontSize(new NonNegativeInteger(fontHeight), i, 0); 
    11421145          store.setRectangleStrokeWidth(lineWidth, i, 0); 
    11431146 
     
    11951198          store.setEllipseRadiusX(rx, i, 0); 
    11961199          store.setEllipseRadiusY(ry, i, 0); 
    1197           store.setEllipseFontSize(fontHeight, i, 0); 
     1200          store.setEllipseFontSize(new NonNegativeInteger(fontHeight), i, 0); 
    11981201          store.setEllipseStrokeWidth(lineWidth, i, 0); 
    11991202 
     
    12131216          store.setEllipseRadiusX(radius, i, 0); 
    12141217          store.setEllipseRadiusY(radius, i, 0); 
    1215           store.setEllipseFontSize(fontHeight, i, 0); 
     1218          store.setEllipseFontSize(new NonNegativeInteger(fontHeight), i, 0); 
    12161219          store.setEllipseStrokeWidth(lineWidth, i, 0); 
    12171220 
     
    12481251          store.setEllipseRadiusX(r, i, 0); 
    12491252          store.setEllipseRadiusY(r, i, 0); 
    1250           store.setEllipseFontSize(fontHeight, i, 0); 
     1253          store.setEllipseFontSize(new NonNegativeInteger(fontHeight), i, 0); 
    12511254          store.setEllipseStrokeWidth(lineWidth, i, 0); 
    12521255 
     
    12701273 
    12711274          store.setPolylinePoints(p.toString(), i, 0); 
    1272           store.setPolylineFontSize(fontHeight, i, 0); 
     1275          store.setPolylineFontSize(new NonNegativeInteger(fontHeight), i, 0); 
    12731276          store.setPolylineStrokeWidth(lineWidth, i, 0); 
    12741277 
     
    12951298          store.setPolylinePoints(p.toString(), i, 0); 
    12961299          store.setPolylineClosed(type == CLOSED_POLYLINE, i, 0); 
    1297           store.setPolylineFontSize(fontHeight, i, 0); 
     1300          store.setPolylineFontSize(new NonNegativeInteger(fontHeight), i, 0); 
    12981301          store.setPolylineStrokeWidth(lineWidth, i, 0); 
    12991302 
     
    13201323          store.setPolylinePoints(p.toString(), i, 0); 
    13211324          store.setPolylineClosed(type != OPEN_BEZIER, i, 0); 
    1322           store.setPolylineFontSize(fontHeight, i, 0); 
     1325          store.setPolylineFontSize(new NonNegativeInteger(fontHeight), i, 0); 
    13231326          store.setPolylineStrokeWidth(lineWidth, i, 0); 
    13241327 
  • trunk/components/bio-formats/src/loci/formats/in/ZeissZVIReader.java

    r6495 r6531  
    918918        } 
    919919        else if (key.startsWith("Objective Magnification")) { 
    920           double mag = Double.parseDouble(value); 
    921           store.setObjectiveNominalMagnification((int) mag, 0, 0); 
     920          store.setObjectiveNominalMagnification( 
     921              new PositiveInteger((int) Double.parseDouble(value)), 0, 0); 
    922922        } 
    923923        else if (key.startsWith("Objective ID")) { 
     
    937937                Double.parseDouble(tokens[q].substring(0, slash - q)); 
    938938              String na = tokens[q].substring(slash + 1); 
    939               store.setObjectiveNominalMagnification(mag, 0, 0); 
     939              store.setObjectiveNominalMagnification( 
     940                  new PositiveInteger(mag), 0, 0); 
    940941              store.setObjectiveLensNA(new Double(na), 0, 0); 
    941942              store.setObjectiveCorrection(getCorrection(tokens[q - 1]), 0, 0); 
  • trunk/components/bio-formats/src/loci/formats/meta/AggregateMetadata.java

    r6458 r6531  
    1 // 
    2 // AggregateMetadata.java 
    3 // 
    41 
    52/* 
    6 OME Bio-Formats package for reading and converting biological file formats. 
    7 Copyright (C) 2005-2010 UW-Madison LOCI and Glencoe Software, Inc. 
    8  
    9 This program is free software; you can redistribute it and/or modify 
    10 it under the terms of the GNU General Public License as published by 
    11 the Free Software Foundation; either version 2 of the License, or 
    12 (at your option) any later version. 
    13  
    14 This program is distributed in the hope that it will be useful, 
    15 but WITHOUT ANY WARRANTY; without even the implied warranty of 
    16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the 
    17 GNU General Public License for more details. 
    18  
    19 You should have received a copy of the GNU General Public License 
    20 along with this program; if not, write to the Free Software 
    21 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA 
    22 */ 
     3 * loci.formats.meta.AggregateMetadata 
     4 * 
     5 *----------------------------------------------------------------------------- 
     6 * 
     7 *  Copyright (C) 2005-@year@ Open Microscopy Environment 
     8 *      Massachusetts Institute of Technology, 
     9 *      National Institutes of Health, 
     10 *      University of Dundee, 
     11 *      University of Wisconsin-Madison 
     12 * 
     13 * 
     14 * 
     15 *    This library is free software; you can redistribute it and/or 
     16 *    modify it under the terms of the GNU Lesser General Public 
     17 *    License as published by the Free Software Foundation; either 
     18 *    version 2.1 of the License, or (at your option) any later version. 
     19 * 
     20 *    This library is distributed in the hope that it will be useful, 
     21 *    but WITHOUT ANY WARRANTY; without even the implied warranty of 
     22 *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU 
     23 *    Lesser General Public License for more details. 
     24 * 
     25 *    You should have received a copy of the GNU Lesser General Public 
     26 *    License along with this library; if not, write to the Free Software 
     27 *    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA 
     28 * 
     29 *----------------------------------------------------------------------------- 
     30 */ 
    2331 
    2432/*----------------------------------------------------------------------------- 
    2533 * 
    2634 * THIS IS AUTOMATICALLY GENERATED CODE.  DO NOT MODIFY. 
    27  * Created by melissa via MetadataAutogen on May 10, 2010 9:27:03 PM CDT 
     35 * Created by callan via xsd-fu on 2010-06-17 12:34:23+0100 
    2836 * 
    2937 *----------------------------------------------------------------------------- 
     
    3442import java.util.Iterator; 
    3543import java.util.List; 
    36  
    37 import loci.common.DataTools; 
    3844 
    3945import ome.xml.model.enums.*; 
     
    5157 * @author Curtis Rueden ctrueden at wisc.edu 
    5258 */ 
    53 public class AggregateMetadata implements IMetadata { 
    54  
    55   // -- Fields -- 
    56  
    57   /** The active metadata store delegates. */ 
    58   private List delegates; 
    59  
    60   // -- Constructor -- 
    61  
    62   /** 
    63    * Creates a new instance. 
    64    * @param delegates of type {@link MetadataRetrieve} 
    65    *   and/or {@link MetadataStore}. 
    66    */ 
    67   public AggregateMetadata(List delegates) { 
    68     this.delegates = delegates; 
    69   } 
    70  
    71   // -- AggregateMetadata API methods -- 
    72  
    73   /** 
    74    * Adds a delegate to the metadata store. 
    75    * @param delegate a <code>MetadataStore</code> 
    76    */ 
    77   public void addDelegate(MetadataStore delegate) { 
    78     delegates.add(delegate); 
    79   } 
    80  
    81   /** 
    82    * Removes a delegate from the metadata store. 
    83    * @param delegate a <code>MetadataStore</code> 
    84    */ 
    85   public void removeDelegate(MetadataStore delegate) { 
    86     delegates.remove(delegate); 
    87   } 
    88  
    89   /** 
    90    * Retrieves the current list of metadata store delegates. 
    91    * @return list of {@link MetadataStore} delegates. 
    92    */ 
    93   public List getDelegates() { 
    94     return delegates; 
    95   } 
    96  
    97   // -- MetadataRetrieve API methods -- 
    98  
    99   // - Entity counting - 
    100  
    101   /* @see MetadataRetrieve#getPixelsBinDataCount(int) */ 
    102   public int getPixelsBinDataCount(int imageIndex) { 
    103     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    104       Object o = iter.next(); 
    105       if (o instanceof MetadataRetrieve) { 
    106         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    107         int result = retrieve.getPixelsBinDataCount(imageIndex); 
    108         if (result >= 0) return result; 
    109       } 
    110     } 
    111     return -1; 
    112   } 
    113  
    114   /* @see MetadataRetrieve#getBooleanAnnotationCount() */ 
    115   public int getBooleanAnnotationCount() { 
    116     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    117       Object o = iter.next(); 
    118       if (o instanceof MetadataRetrieve) { 
    119         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    120         int result = retrieve.getBooleanAnnotationCount(); 
    121         if (result >= 0) return result; 
    122       } 
    123     } 
    124     return -1; 
    125   } 
    126  
    127   /* @see MetadataRetrieve#getChannelCount(int) */ 
    128   public int getChannelCount(int imageIndex) { 
    129     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    130       Object o = iter.next(); 
    131       if (o instanceof MetadataRetrieve) { 
    132         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    133         int result = retrieve.getChannelCount(imageIndex); 
    134         if (result >= 0) return result; 
    135       } 
    136     } 
    137     return -1; 
    138   } 
    139  
    140   /* @see MetadataRetrieve#getChannelAnnotationRefCount(int, int) */ 
    141   public int getChannelAnnotationRefCount(int imageIndex, int channelIndex) { 
    142     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    143       Object o = iter.next(); 
    144       if (o instanceof MetadataRetrieve) { 
    145         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    146         int result = retrieve.getChannelAnnotationRefCount(imageIndex, channelIndex); 
    147         if (result >= 0) return result; 
    148       } 
    149     } 
    150     return -1; 
    151   } 
    152  
    153   /* @see MetadataRetrieve#getDatasetCount() */ 
    154   public int getDatasetCount() { 
    155     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    156       Object o = iter.next(); 
    157       if (o instanceof MetadataRetrieve) { 
    158         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    159         int result = retrieve.getDatasetCount(); 
    160         if (result >= 0) return result; 
    161       } 
    162     } 
    163     return -1; 
    164   } 
    165  
    166   /* @see MetadataRetrieve#getDatasetAnnotationRefCount(int) */ 
    167   public int getDatasetAnnotationRefCount(int datasetIndex) { 
    168     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    169       Object o = iter.next(); 
    170       if (o instanceof MetadataRetrieve) { 
    171         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    172         int result = retrieve.getDatasetAnnotationRefCount(datasetIndex); 
    173         if (result >= 0) return result; 
    174       } 
    175     } 
    176     return -1; 
    177   } 
    178  
    179   /* @see MetadataRetrieve#getDatasetRefCount(int) */ 
    180   public int getDatasetRefCount(int imageIndex) { 
    181     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    182       Object o = iter.next(); 
    183       if (o instanceof MetadataRetrieve) { 
    184         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    185         int result = retrieve.getDatasetRefCount(imageIndex); 
    186         if (result >= 0) return result; 
    187       } 
    188     } 
    189     return -1; 
    190   } 
    191  
    192   /* @see MetadataRetrieve#getDetectorCount(int) */ 
    193   public int getDetectorCount(int instrumentIndex) { 
    194     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    195       Object o = iter.next(); 
    196       if (o instanceof MetadataRetrieve) { 
    197         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    198         int result = retrieve.getDetectorCount(instrumentIndex); 
    199         if (result >= 0) return result; 
    200       } 
    201     } 
    202     return -1; 
    203   } 
    204  
    205   /* @see MetadataRetrieve#getDichroicCount(int) */ 
    206   public int getDichroicCount(int instrumentIndex) { 
    207     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    208       Object o = iter.next(); 
    209       if (o instanceof MetadataRetrieve) { 
    210         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    211         int result = retrieve.getDichroicCount(instrumentIndex); 
    212         if (result >= 0) return result; 
    213       } 
    214     } 
    215     return -1; 
    216   } 
    217  
    218   /* @see MetadataRetrieve#getDoubleAnnotationCount() */ 
    219   public int getDoubleAnnotationCount() { 
    220     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    221       Object o = iter.next(); 
    222       if (o instanceof MetadataRetrieve) { 
    223         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    224         int result = retrieve.getDoubleAnnotationCount(); 
    225         if (result >= 0) return result; 
    226       } 
    227     } 
    228     return -1; 
    229   } 
    230  
    231   /* @see MetadataRetrieve#getExperimentCount() */ 
    232   public int getExperimentCount() { 
    233     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    234       Object o = iter.next(); 
    235       if (o instanceof MetadataRetrieve) { 
    236         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    237         int result = retrieve.getExperimentCount(); 
    238         if (result >= 0) return result; 
    239       } 
    240     } 
    241     return -1; 
    242   } 
    243  
    244   /* @see MetadataRetrieve#getExperimenterCount() */ 
    245   public int getExperimenterCount() { 
    246     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    247       Object o = iter.next(); 
    248       if (o instanceof MetadataRetrieve) { 
    249         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    250         int result = retrieve.getExperimenterCount(); 
    251         if (result >= 0) return result; 
    252       } 
    253     } 
    254     return -1; 
    255   } 
    256  
    257   /* @see MetadataRetrieve#getExperimenterAnnotationRefCount(int) */ 
    258   public int getExperimenterAnnotationRefCount(int experimenterIndex) { 
    259     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    260       Object o = iter.next(); 
    261       if (o instanceof MetadataRetrieve) { 
    262         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    263         int result = retrieve.getExperimenterAnnotationRefCount(experimenterIndex); 
    264         if (result >= 0) return result; 
    265       } 
    266     } 
    267     return -1; 
    268   } 
    269  
    270   /* @see MetadataRetrieve#getExperimenterGroupRefCount(int) */ 
    271   public int getExperimenterGroupRefCount(int experimenterIndex) { 
    272     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    273       Object o = iter.next(); 
    274       if (o instanceof MetadataRetrieve) { 
    275         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    276         int result = retrieve.getExperimenterGroupRefCount(experimenterIndex); 
    277         if (result >= 0) return result; 
    278       } 
    279     } 
    280     return -1; 
    281   } 
    282  
    283   /* @see MetadataRetrieve#getFileAnnotationCount() */ 
    284   public int getFileAnnotationCount() { 
    285     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    286       Object o = iter.next(); 
    287       if (o instanceof MetadataRetrieve) { 
    288         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    289         int result = retrieve.getFileAnnotationCount(); 
    290         if (result >= 0) return result; 
    291       } 
    292     } 
    293     return -1; 
    294   } 
    295  
    296   /* @see MetadataRetrieve#getFilterCount(int) */ 
    297   public int getFilterCount(int instrumentIndex) { 
    298     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    299       Object o = iter.next(); 
    300       if (o instanceof MetadataRetrieve) { 
    301         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    302         int result = retrieve.getFilterCount(instrumentIndex); 
    303         if (result >= 0) return result; 
    304       } 
    305     } 
    306     return -1; 
    307   } 
    308  
    309   /* @see MetadataRetrieve#getFilterSetCount(int) */ 
    310   public int getFilterSetCount(int instrumentIndex) { 
    311     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    312       Object o = iter.next(); 
    313       if (o instanceof MetadataRetrieve) { 
    314         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    315         int result = retrieve.getFilterSetCount(instrumentIndex); 
    316         if (result >= 0) return result; 
    317       } 
    318     } 
    319     return -1; 
    320   } 
    321  
    322   /* @see MetadataRetrieve#getFilterSetEmissionFilterRefCount(int, int) */ 
    323   public int getFilterSetEmissionFilterRefCount(int instrumentIndex, int filterSetIndex) { 
    324     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    325       Object o = iter.next(); 
    326       if (o instanceof MetadataRetrieve) { 
    327         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    328         int result = retrieve.getFilterSetEmissionFilterRefCount(instrumentIndex, filterSetIndex); 
    329         if (result >= 0) return result; 
    330       } 
    331     } 
    332     return -1; 
    333   } 
    334  
    335   /* @see MetadataRetrieve#getFilterSetExcitationFilterRefCount(int, int) */ 
    336   public int getFilterSetExcitationFilterRefCount(int instrumentIndex, int filterSetIndex) { 
    337     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    338       Object o = iter.next(); 
    339       if (o instanceof MetadataRetrieve) { 
    340         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    341         int result = retrieve.getFilterSetExcitationFilterRefCount(instrumentIndex, filterSetIndex); 
    342         if (result >= 0) return result; 
    343       } 
    344     } 
    345     return -1; 
    346   } 
    347  
    348   /* @see MetadataRetrieve#getGroupCount() */ 
    349   public int getGroupCount() { 
    350     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    351       Object o = iter.next(); 
    352       if (o instanceof MetadataRetrieve) { 
    353         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    354         int result = retrieve.getGroupCount(); 
    355         if (result >= 0) return result; 
    356       } 
    357     } 
    358     return -1; 
    359   } 
    360  
    361   /* @see MetadataRetrieve#getImageCount() */ 
    362   public int getImageCount() { 
    363     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    364       Object o = iter.next(); 
    365       if (o instanceof MetadataRetrieve) { 
    366         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    367         int result = retrieve.getImageCount(); 
    368         if (result >= 0) return result; 
    369       } 
    370     } 
    371     return -1; 
    372   } 
    373  
    374   /* @see MetadataRetrieve#getImageAnnotationRefCount(int) */ 
    375   public int getImageAnnotationRefCount(int imageIndex) { 
    376     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    377       Object o = iter.next(); 
    378       if (o instanceof MetadataRetrieve) { 
    379         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    380         int result = retrieve.getImageAnnotationRefCount(imageIndex); 
    381         if (result >= 0) return result; 
    382       } 
    383     } 
    384     return -1; 
    385   } 
    386  
    387   /* @see MetadataRetrieve#getImageROIRefCount(int) */ 
    388   public int getImageROIRefCount(int imageIndex) { 
    389     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    390       Object o = iter.next(); 
    391       if (o instanceof MetadataRetrieve) { 
    392         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    393         int result = retrieve.getImageROIRefCount(imageIndex); 
    394         if (result >= 0) return result; 
    395       } 
    396     } 
    397     return -1; 
    398   } 
    399  
    400   /* @see MetadataRetrieve#getInstrumentCount() */ 
    401   public int getInstrumentCount() { 
    402     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    403       Object o = iter.next(); 
    404       if (o instanceof MetadataRetrieve) { 
    405         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    406         int result = retrieve.getInstrumentCount(); 
    407         if (result >= 0) return result; 
    408       } 
    409     } 
    410     return -1; 
    411   } 
    412  
    413   /* @see MetadataRetrieve#getLightPathEmissionFilterRefCount(int, int) */ 
    414   public int getLightPathEmissionFilterRefCount(int imageIndex, int channelIndex) { 
    415     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    416       Object o = iter.next(); 
    417       if (o instanceof MetadataRetrieve) { 
    418         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    419         int result = retrieve.getLightPathEmissionFilterRefCount(imageIndex, channelIndex); 
    420         if (result >= 0) return result; 
    421       } 
    422     } 
    423     return -1; 
    424   } 
    425  
    426   /* @see MetadataRetrieve#getLightPathExcitationFilterRefCount(int, int) */ 
    427   public int getLightPathExcitationFilterRefCount(int imageIndex, int channelIndex) { 
    428     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    429       Object o = iter.next(); 
    430       if (o instanceof MetadataRetrieve) { 
    431         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    432         int result = retrieve.getLightPathExcitationFilterRefCount(imageIndex, channelIndex); 
    433         if (result >= 0) return result; 
    434       } 
    435     } 
    436     return -1; 
    437   } 
    438  
    439   /* @see MetadataRetrieve#getListAnnotationCount() */ 
    440   public int getListAnnotationCount() { 
    441     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    442       Object o = iter.next(); 
    443       if (o instanceof MetadataRetrieve) { 
    444         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    445         int result = retrieve.getListAnnotationCount(); 
    446         if (result >= 0) return result; 
    447       } 
    448     } 
    449     return -1; 
    450   } 
    451  
    452   /* @see MetadataRetrieve#getListAnnotationAnnotationRefCount(int) */ 
    453   public int getListAnnotationAnnotationRefCount(int listAnnotationIndex) { 
    454     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    455       Object o = iter.next(); 
    456       if (o instanceof MetadataRetrieve) { 
    457         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    458         int result = retrieve.getListAnnotationAnnotationRefCount(listAnnotationIndex); 
    459         if (result >= 0) return result; 
    460       } 
    461     } 
    462     return -1; 
    463   } 
    464  
    465   /* @see MetadataRetrieve#getLongAnnotationCount() */ 
    466   public int getLongAnnotationCount() { 
    467     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    468       Object o = iter.next(); 
    469       if (o instanceof MetadataRetrieve) { 
    470         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    471         int result = retrieve.getLongAnnotationCount(); 
    472         if (result >= 0) return result; 
    473       } 
    474     } 
    475     return -1; 
    476   } 
    477  
    478   /* @see MetadataRetrieve#getMicrobeamManipulationCount(int) */ 
    479   public int getMicrobeamManipulationCount(int experimentIndex) { 
    480     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    481       Object o = iter.next(); 
    482       if (o instanceof MetadataRetrieve) { 
    483         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    484         int result = retrieve.getMicrobeamManipulationCount(experimentIndex); 
    485         if (result >= 0) return result; 
    486       } 
    487     } 
    488     return -1; 
    489   } 
    490  
    491   /* @see MetadataRetrieve#getMicrobeamManipulationLightSourceSettingsCount(int, int) */ 
    492   public int getMicrobeamManipulationLightSourceSettingsCount(int experimentIndex, int microbeamManipulationIndex) { 
    493     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    494       Object o = iter.next(); 
    495       if (o instanceof MetadataRetrieve) { 
    496         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    497         int result = retrieve.getMicrobeamManipulationLightSourceSettingsCount(experimentIndex, microbeamManipulationIndex); 
    498         if (result >= 0) return result; 
    499       } 
    500     } 
    501     return -1; 
    502   } 
    503  
    504   /* @see MetadataRetrieve#getMicrobeamManipulationROIRefCount(int, int) */ 
    505   public int getMicrobeamManipulationROIRefCount(int experimentIndex, int microbeamManipulationIndex) { 
    506     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    507       Object o = iter.next(); 
    508       if (o instanceof MetadataRetrieve) { 
    509         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    510         int result = retrieve.getMicrobeamManipulationROIRefCount(experimentIndex, microbeamManipulationIndex); 
    511         if (result >= 0) return result; 
    512       } 
    513     } 
    514     return -1; 
    515   } 
    516  
    517   /* @see MetadataRetrieve#getMicrobeamManipulationRefCount(int) */ 
    518   public int getMicrobeamManipulationRefCount(int imageIndex) { 
    519     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    520       Object o = iter.next(); 
    521       if (o instanceof MetadataRetrieve) { 
    522         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    523         int result = retrieve.getMicrobeamManipulationRefCount(imageIndex); 
    524         if (result >= 0) return result; 
    525       } 
    526     } 
    527     return -1; 
    528   } 
    529  
    530   /* @see MetadataRetrieve#getOTFCount(int) */ 
    531   public int getOTFCount(int instrumentIndex) { 
    532     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    533       Object o = iter.next(); 
    534       if (o instanceof MetadataRetrieve) { 
    535         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    536         int result = retrieve.getOTFCount(instrumentIndex); 
    537         if (result >= 0) return result; 
    538       } 
    539     } 
    540     return -1; 
    541   } 
    542  
    543   /* @see MetadataRetrieve#getObjectiveCount(int) */ 
    544   public int getObjectiveCount(int instrumentIndex) { 
    545     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    546       Object o = iter.next(); 
    547       if (o instanceof MetadataRetrieve) { 
    548         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    549         int result = retrieve.getObjectiveCount(instrumentIndex); 
    550         if (result >= 0) return result; 
    551       } 
    552     } 
    553     return -1; 
    554   } 
    555  
    556   /* @see MetadataRetrieve#getPixelsAnnotationRefCount(int) */ 
    557   public int getPixelsAnnotationRefCount(int imageIndex) { 
    558     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    559       Object o = iter.next(); 
    560       if (o instanceof MetadataRetrieve) { 
    561         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    562         int result = retrieve.getPixelsAnnotationRefCount(imageIndex); 
    563         if (result >= 0) return result; 
    564       } 
    565     } 
    566     return -1; 
    567   } 
    568  
    569   /* @see MetadataRetrieve#getPlaneCount(int) */ 
    570   public int getPlaneCount(int imageIndex) { 
    571     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    572       Object o = iter.next(); 
    573       if (o instanceof MetadataRetrieve) { 
    574         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    575         int result = retrieve.getPlaneCount(imageIndex); 
    576         if (result >= 0) return result; 
    577       } 
    578     } 
    579     return -1; 
    580   } 
    581  
    582   /* @see MetadataRetrieve#getPlaneAnnotationRefCount(int, int) */ 
    583   public int getPlaneAnnotationRefCount(int imageIndex, int planeIndex) { 
    584     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    585       Object o = iter.next(); 
    586       if (o instanceof MetadataRetrieve) { 
    587         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    588         int result = retrieve.getPlaneAnnotationRefCount(imageIndex, planeIndex); 
    589         if (result >= 0) return result; 
    590       } 
    591     } 
    592     return -1; 
    593   } 
    594  
    595   /* @see MetadataRetrieve#getPlateCount() */ 
    596   public int getPlateCount() { 
    597     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    598       Object o = iter.next(); 
    599       if (o instanceof MetadataRetrieve) { 
    600         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    601         int result = retrieve.getPlateCount(); 
    602         if (result >= 0) return result; 
    603       } 
    604     } 
    605     return -1; 
    606   } 
    607  
    608   /* @see MetadataRetrieve#getPlateAcquisitionCount(int) */ 
    609   public int getPlateAcquisitionCount(int plateIndex) { 
    610     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    611       Object o = iter.next(); 
    612       if (o instanceof MetadataRetrieve) { 
    613         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    614         int result = retrieve.getPlateAcquisitionCount(plateIndex); 
    615         if (result >= 0) return result; 
    616       } 
    617     } 
    618     return -1; 
    619   } 
    620  
    621   /* @see MetadataRetrieve#getPlateAcquisitionAnnotationRefCount(int, int) */ 
    622   public int getPlateAcquisitionAnnotationRefCount(int plateIndex, int plateAcquisitionIndex) { 
    623     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    624       Object o = iter.next(); 
    625       if (o instanceof MetadataRetrieve) { 
    626         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    627         int result = retrieve.getPlateAcquisitionAnnotationRefCount(plateIndex, plateAcquisitionIndex); 
    628         if (result >= 0) return result; 
    629       } 
    630     } 
    631     return -1; 
    632   } 
    633  
    634   /* @see MetadataRetrieve#getPlateAnnotationRefCount(int) */ 
    635   public int getPlateAnnotationRefCount(int plateIndex) { 
    636     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    637       Object o = iter.next(); 
    638       if (o instanceof MetadataRetrieve) { 
    639         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    640         int result = retrieve.getPlateAnnotationRefCount(plateIndex); 
    641         if (result >= 0) return result; 
    642       } 
    643     } 
    644     return -1; 
    645   } 
    646  
    647   /* @see MetadataRetrieve#getPlateRefCount(int) */ 
    648   public int getPlateRefCount(int screenIndex) { 
    649     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    650       Object o = iter.next(); 
    651       if (o instanceof MetadataRetrieve) { 
    652         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    653         int result = retrieve.getPlateRefCount(screenIndex); 
    654         if (result >= 0) return result; 
    655       } 
    656     } 
    657     return -1; 
    658   } 
    659  
    660   /* @see MetadataRetrieve#getProjectCount() */ 
    661   public int getProjectCount() { 
    662     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    663       Object o = iter.next(); 
    664       if (o instanceof MetadataRetrieve) { 
    665         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    666         int result = retrieve.getProjectCount(); 
    667         if (result >= 0) return result; 
    668       } 
    669     } 
    670     return -1; 
    671   } 
    672  
    673   /* @see MetadataRetrieve#getProjectAnnotationRefCount(int) */ 
    674   public int getProjectAnnotationRefCount(int projectIndex) { 
    675     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    676       Object o = iter.next(); 
    677       if (o instanceof MetadataRetrieve) { 
    678         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    679         int result = retrieve.getProjectAnnotationRefCount(projectIndex); 
    680         if (result >= 0) return result; 
    681       } 
    682     } 
    683     return -1; 
    684   } 
    685  
    686   /* @see MetadataRetrieve#getProjectRefCount(int) */ 
    687   public int getProjectRefCount(int datasetIndex) { 
    688     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    689       Object o = iter.next(); 
    690       if (o instanceof MetadataRetrieve) { 
    691         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    692         int result = retrieve.getProjectRefCount(datasetIndex); 
    693         if (result >= 0) return result; 
    694       } 
    695     } 
    696     return -1; 
    697   } 
    698  
    699   /* @see MetadataRetrieve#getROICount() */ 
    700   public int getROICount() { 
    701     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    702       Object o = iter.next(); 
    703       if (o instanceof MetadataRetrieve) { 
    704         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    705         int result = retrieve.getROICount(); 
    706         if (result >= 0) return result; 
    707       } 
    708     } 
    709     return -1; 
    710   } 
    711  
    712   /* @see MetadataRetrieve#getROIAnnotationRefCount(int) */ 
    713   public int getROIAnnotationRefCount(int roiIndex) { 
    714     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    715       Object o = iter.next(); 
    716       if (o instanceof MetadataRetrieve) { 
    717         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    718         int result = retrieve.getROIAnnotationRefCount(roiIndex); 
    719         if (result >= 0) return result; 
    720       } 
    721     } 
    722     return -1; 
    723   } 
    724  
    725   /* @see MetadataRetrieve#getReagentCount(int) */ 
    726   public int getReagentCount(int screenIndex) { 
    727     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    728       Object o = iter.next(); 
    729       if (o instanceof MetadataRetrieve) { 
    730         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    731         int result = retrieve.getReagentCount(screenIndex); 
    732         if (result >= 0) return result; 
    733       } 
    734     } 
    735     return -1; 
    736   } 
    737  
    738   /* @see MetadataRetrieve#getReagentAnnotationRefCount(int, int) */ 
    739   public int getReagentAnnotationRefCount(int screenIndex, int reagentIndex) { 
    740     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    741       Object o = iter.next(); 
    742       if (o instanceof MetadataRetrieve) { 
    743         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    744         int result = retrieve.getReagentAnnotationRefCount(screenIndex, reagentIndex); 
    745         if (result >= 0) return result; 
    746       } 
    747     } 
    748     return -1; 
    749   } 
    750  
    751   /* @see MetadataRetrieve#getScreenCount() */ 
    752   public int getScreenCount() { 
    753     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    754       Object o = iter.next(); 
    755       if (o instanceof MetadataRetrieve) { 
    756         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    757         int result = retrieve.getScreenCount(); 
    758         if (result >= 0) return result; 
    759       } 
    760     } 
    761     return -1; 
    762   } 
    763  
    764   /* @see MetadataRetrieve#getScreenAnnotationRefCount(int) */ 
    765   public int getScreenAnnotationRefCount(int screenIndex) { 
    766     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    767       Object o = iter.next(); 
    768       if (o instanceof MetadataRetrieve) { 
    769         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    770         int result = retrieve.getScreenAnnotationRefCount(screenIndex); 
    771         if (result >= 0) return result; 
    772       } 
    773     } 
    774     return -1; 
    775   } 
    776  
    777   /* @see MetadataRetrieve#getScreenRefCount(int) */ 
    778   public int getScreenRefCount(int plateIndex) { 
    779     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    780       Object o = iter.next(); 
    781       if (o instanceof MetadataRetrieve) { 
    782         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    783         int result = retrieve.getScreenRefCount(plateIndex); 
    784         if (result >= 0) return result; 
    785       } 
    786     } 
    787     return -1; 
    788   } 
    789  
    790   /* @see MetadataRetrieve#getShapeAnnotationRefCount(int, int) */ 
    791   public int getShapeAnnotationRefCount(int roiIndex, int shapeIndex) { 
    792     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    793       Object o = iter.next(); 
    794       if (o instanceof MetadataRetrieve) { 
    795         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    796         int result = retrieve.getShapeAnnotationRefCount(roiIndex, shapeIndex); 
    797         if (result >= 0) return result; 
    798       } 
    799     } 
    800     return -1; 
    801   } 
    802  
    803   /* @see MetadataRetrieve#getStringAnnotationCount() */ 
    804   public int getStringAnnotationCount() { 
    805     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    806       Object o = iter.next(); 
    807       if (o instanceof MetadataRetrieve) { 
    808         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    809         int result = retrieve.getStringAnnotationCount(); 
    810         if (result >= 0) return result; 
    811       } 
    812     } 
    813     return -1; 
    814   } 
    815  
    816   /* @see MetadataRetrieve#getTiffDataCount(int) */ 
    817   public int getTiffDataCount(int imageIndex) { 
    818     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    819       Object o = iter.next(); 
    820       if (o instanceof MetadataRetrieve) { 
    821         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    822         int result = retrieve.getTiffDataCount(imageIndex); 
    823         if (result >= 0) return result; 
    824       } 
    825     } 
    826     return -1; 
    827   } 
    828  
    829   /* @see MetadataRetrieve#getTimestampAnnotationCount() */ 
    830   public int getTimestampAnnotationCount() { 
    831     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    832       Object o = iter.next(); 
    833       if (o instanceof MetadataRetrieve) { 
    834         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    835         int result = retrieve.getTimestampAnnotationCount(); 
    836         if (result >= 0) return result; 
    837       } 
    838     } 
    839     return -1; 
    840   } 
    841  
    842   /* @see MetadataRetrieve#getWellCount(int) */ 
    843   public int getWellCount(int plateIndex) { 
    844     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    845       Object o = iter.next(); 
    846       if (o instanceof MetadataRetrieve) { 
    847         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    848         int result = retrieve.getWellCount(plateIndex); 
    849         if (result >= 0) return result; 
    850       } 
    851     } 
    852     return -1; 
    853   } 
    854  
    855   /* @see MetadataRetrieve#getWellAnnotationRefCount(int, int) */ 
    856   public int getWellAnnotationRefCount(int plateIndex, int wellIndex) { 
    857     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    858       Object o = iter.next(); 
    859       if (o instanceof MetadataRetrieve) { 
    860         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    861         int result = retrieve.getWellAnnotationRefCount(plateIndex, wellIndex); 
    862         if (result >= 0) return result; 
    863       } 
    864     } 
    865     return -1; 
    866   } 
    867  
    868   /* @see MetadataRetrieve#getWellSampleCount(int, int) */ 
    869   public int getWellSampleCount(int plateIndex, int wellIndex) { 
    870     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    871       Object o = iter.next(); 
    872       if (o instanceof MetadataRetrieve) { 
    873         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    874         int result = retrieve.getWellSampleCount(plateIndex, wellIndex); 
    875         if (result >= 0) return result; 
    876       } 
    877     } 
    878     return -1; 
    879   } 
    880  
    881   /* @see MetadataRetrieve#getWellSampleAnnotationRefCount(int, int, int) */ 
    882   public int getWellSampleAnnotationRefCount(int plateIndex, int wellIndex, int wellSampleIndex) { 
    883     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    884       Object o = iter.next(); 
    885       if (o instanceof MetadataRetrieve) { 
    886         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    887         int result = retrieve.getWellSampleAnnotationRefCount(plateIndex, wellIndex, wellSampleIndex); 
    888         if (result >= 0) return result; 
    889       } 
    890     } 
    891     return -1; 
    892   } 
    893  
    894   /* @see MetadataRetrieve#getWellSampleRefCount(int, int) */ 
    895   public int getWellSampleRefCount(int plateIndex, int plateAcquisitionIndex) { 
    896     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    897       Object o = iter.next(); 
    898       if (o instanceof MetadataRetrieve) { 
    899         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    900         int result = retrieve.getWellSampleRefCount(plateIndex, plateAcquisitionIndex); 
    901         if (result >= 0) return result; 
    902       } 
    903     } 
    904     return -1; 
    905   } 
    906  
    907   /* @see MetadataRetrieve#getXMLAnnotationCount() */ 
    908   public int getXMLAnnotationCount() { 
    909     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    910       Object o = iter.next(); 
    911       if (o instanceof MetadataRetrieve) { 
    912         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    913         int result = retrieve.getXMLAnnotationCount(); 
    914         if (result >= 0) return result; 
    915       } 
    916     } 
    917     return -1; 
    918   } 
    919  
    920   // - Entity retrieval - 
    921  
    922   /* @see MetadataRetrieve#getUUID() */ 
    923   public String getUUID() { 
    924     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    925       Object o = iter.next(); 
    926       if (o instanceof MetadataRetrieve) { 
    927         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    928         String result = retrieve.getUUID(); 
    929         if (result != null) return result; 
    930       } 
    931     } 
    932     return null; 
    933   } 
    934  
    935   // - Arc property retrieval - 
    936  
    937   /* @see MetadataRetrieve#getArcID(int, int) */ 
    938   public String getArcID(int instrumentIndex, int arcIndex) { 
    939     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    940       Object o = iter.next(); 
    941       if (o instanceof MetadataRetrieve) { 
    942         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    943         String result = retrieve.getArcID(instrumentIndex, arcIndex); 
    944         if (result != null) return result; 
    945       } 
    946     } 
    947     return null; 
    948   } 
    949  
    950   /* @see MetadataRetrieve#getArcLotNumber(int, int) */ 
    951   public String getArcLotNumber(int instrumentIndex, int arcIndex) { 
    952     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    953       Object o = iter.next(); 
    954       if (o instanceof MetadataRetrieve) { 
    955         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    956         String result = retrieve.getArcLotNumber(instrumentIndex, arcIndex); 
    957         if (result != null) return result; 
    958       } 
    959     } 
    960     return null; 
    961   } 
    962  
    963   /* @see MetadataRetrieve#getArcManufacturer(int, int) */ 
    964   public String getArcManufacturer(int instrumentIndex, int arcIndex) { 
    965     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    966       Object o = iter.next(); 
    967       if (o instanceof MetadataRetrieve) { 
    968         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    969         String result = retrieve.getArcManufacturer(instrumentIndex, arcIndex); 
    970         if (result != null) return result; 
    971       } 
    972     } 
    973     return null; 
    974   } 
    975  
    976   /* @see MetadataRetrieve#getArcModel(int, int) */ 
    977   public String getArcModel(int instrumentIndex, int arcIndex) { 
    978     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    979       Object o = iter.next(); 
    980       if (o instanceof MetadataRetrieve) { 
    981         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    982         String result = retrieve.getArcModel(instrumentIndex, arcIndex); 
    983         if (result != null) return result; 
    984       } 
    985     } 
    986     return null; 
    987   } 
    988  
    989   /* @see MetadataRetrieve#getArcPower(int, int) */ 
    990   public Double getArcPower(int instrumentIndex, int arcIndex) { 
    991     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    992       Object o = iter.next(); 
    993       if (o instanceof MetadataRetrieve) { 
    994         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    995         Double result = retrieve.getArcPower(instrumentIndex, arcIndex); 
    996         if (result != null) return result; 
    997       } 
    998     } 
    999     return null; 
    1000   } 
    1001  
    1002   /* @see MetadataRetrieve#getArcSerialNumber(int, int) */ 
    1003   public String getArcSerialNumber(int instrumentIndex, int arcIndex) { 
    1004     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    1005       Object o = iter.next(); 
    1006       if (o instanceof MetadataRetrieve) { 
    1007         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    1008         String result = retrieve.getArcSerialNumber(instrumentIndex, arcIndex); 
    1009         if (result != null) return result; 
    1010       } 
    1011     } 
    1012     return null; 
    1013   } 
    1014  
    1015   /* @see MetadataRetrieve#getArcType(int, int) */ 
    1016   public ArcType getArcType(int instrumentIndex, int arcIndex) { 
    1017     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    1018       Object o = iter.next(); 
    1019       if (o instanceof MetadataRetrieve) { 
    1020         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    1021         ArcType result = retrieve.getArcType(instrumentIndex, arcIndex); 
    1022         if (result != null) return result; 
    1023       } 
    1024     } 
    1025     return null; 
    1026   } 
    1027  
    1028   // - BooleanAnnotation property retrieval - 
    1029  
    1030   /* @see MetadataRetrieve#getBooleanAnnotationID(int) */ 
    1031   public String getBooleanAnnotationID(int booleanAnnotationIndex) { 
    1032     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    1033       Object o = iter.next(); 
    1034       if (o instanceof MetadataRetrieve) { 
    1035         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    1036         String result = retrieve.getBooleanAnnotationID(booleanAnnotationIndex); 
    1037         if (result != null) return result; 
    1038       } 
    1039     } 
    1040     return null; 
    1041   } 
    1042  
    1043   /* @see MetadataRetrieve#getBooleanAnnotationNamespace(int) */ 
    1044   public String getBooleanAnnotationNamespace(int booleanAnnotationIndex) { 
    1045     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    1046       Object o = iter.next(); 
    1047       if (o instanceof MetadataRetrieve) { 
    1048         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    1049         String result = retrieve.getBooleanAnnotationNamespace(booleanAnnotationIndex); 
    1050         if (result != null) return result; 
    1051       } 
    1052     } 
    1053     return null; 
    1054   } 
    1055  
    1056   /* @see MetadataRetrieve#getBooleanAnnotationValue(int) */ 
    1057   public Boolean getBooleanAnnotationValue(int booleanAnnotationIndex) { 
    1058     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    1059       Object o = iter.next(); 
    1060       if (o instanceof MetadataRetrieve) { 
    1061         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    1062         Boolean result = retrieve.getBooleanAnnotationValue(booleanAnnotationIndex); 
    1063         if (result != null) return result; 
    1064       } 
    1065     } 
    1066     return null; 
    1067   } 
    1068  
    1069   // - Channel property retrieval - 
    1070  
    1071   /* @see MetadataRetrieve#getChannelAcquisitionMode(int, int) */ 
    1072   public AcquisitionMode getChannelAcquisitionMode(int imageIndex, int channelIndex) { 
    1073     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    1074       Object o = iter.next(); 
    1075       if (o instanceof MetadataRetrieve) { 
    1076         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    1077         AcquisitionMode result = retrieve.getChannelAcquisitionMode(imageIndex, channelIndex); 
    1078         if (result != null) return result; 
    1079       } 
    1080     } 
    1081     return null; 
    1082   } 
    1083  
    1084   /* @see MetadataRetrieve#getChannelAnnotationRef(int, int, int) */ 
    1085   public String getChannelAnnotationRef(int imageIndex, int channelIndex, int annotationRefIndex) { 
    1086     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    1087       Object o = iter.next(); 
    1088       if (o instanceof MetadataRetrieve) { 
    1089         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    1090         String result = retrieve.getChannelAnnotationRef(imageIndex, channelIndex, annotationRefIndex); 
    1091         if (result != null) return result; 
    1092       } 
    1093     } 
    1094     return null; 
    1095   } 
    1096  
    1097   /* @see MetadataRetrieve#getChannelColor(int, int) */ 
    1098   public Integer getChannelColor(int imageIndex, int channelIndex) { 
    1099     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    1100       Object o = iter.next(); 
    1101       if (o instanceof MetadataRetrieve) { 
    1102         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    1103         Integer result = retrieve.getChannelColor(imageIndex, channelIndex); 
    1104         if (result != null) return result; 
    1105       } 
    1106     } 
    1107     return null; 
    1108   } 
    1109  
    1110   /* @see MetadataRetrieve#getChannelContrastMethod(int, int) */ 
    1111   public ContrastMethod getChannelContrastMethod(int imageIndex, int channelIndex) { 
    1112     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    1113       Object o = iter.next(); 
    1114       if (o instanceof MetadataRetrieve) { 
    1115         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    1116         ContrastMethod result = retrieve.getChannelContrastMethod(imageIndex, channelIndex); 
    1117         if (result != null) return result; 
    1118       } 
    1119     } 
    1120     return null; 
    1121   } 
    1122  
    1123   /* @see MetadataRetrieve#getChannelEmissionWavelength(int, int) */ 
    1124   public PositiveInteger getChannelEmissionWavelength(int imageIndex, int channelIndex) { 
    1125     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    1126       Object o = iter.next(); 
    1127       if (o instanceof MetadataRetrieve) { 
    1128         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    1129         PositiveInteger result = retrieve.getChannelEmissionWavelength(imageIndex, channelIndex); 
    1130         if (result != null) return result; 
    1131       } 
    1132     } 
    1133     return null; 
    1134   } 
    1135  
    1136   /* @see MetadataRetrieve#getChannelExcitationWavelength(int, int) */ 
    1137   public PositiveInteger getChannelExcitationWavelength(int imageIndex, int channelIndex) { 
    1138     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    1139       Object o = iter.next(); 
    1140       if (o instanceof MetadataRetrieve) { 
    1141         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    1142         PositiveInteger result = retrieve.getChannelExcitationWavelength(imageIndex, channelIndex); 
    1143         if (result != null) return result; 
    1144       } 
    1145     } 
    1146     return null; 
    1147   } 
    1148  
    1149   /* @see MetadataRetrieve#getChannelFilterSetRef(int, int) */ 
    1150   public String getChannelFilterSetRef(int imageIndex, int channelIndex) { 
    1151     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    1152       Object o = iter.next(); 
    1153       if (o instanceof MetadataRetrieve) { 
    1154         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    1155         String result = retrieve.getChannelFilterSetRef(imageIndex, channelIndex); 
    1156         if (result != null) return result; 
    1157       } 
    1158     } 
    1159     return null; 
    1160   } 
    1161  
    1162   /* @see MetadataRetrieve#getChannelFluor(int, int) */ 
    1163   public String getChannelFluor(int imageIndex, int channelIndex) { 
    1164     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    1165       Object o = iter.next(); 
    1166       if (o instanceof MetadataRetrieve) { 
    1167         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    1168         String result = retrieve.getChannelFluor(imageIndex, channelIndex); 
    1169         if (result != null) return result; 
    1170       } 
    1171     } 
    1172     return null; 
    1173   } 
    1174  
    1175   /* @see MetadataRetrieve#getChannelID(int, int) */ 
    1176   public String getChannelID(int imageIndex, int channelIndex) { 
    1177     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    1178       Object o = iter.next(); 
    1179       if (o instanceof MetadataRetrieve) { 
    1180         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    1181         String result = retrieve.getChannelID(imageIndex, channelIndex); 
    1182         if (result != null) return result; 
    1183       } 
    1184     } 
    1185     return null; 
    1186   } 
    1187  
    1188   /* @see MetadataRetrieve#getChannelIlluminationType(int, int) */ 
    1189   public IlluminationType getChannelIlluminationType(int imageIndex, int channelIndex) { 
    1190     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    1191       Object o = iter.next(); 
    1192       if (o instanceof MetadataRetrieve) { 
    1193         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    1194         IlluminationType result = retrieve.getChannelIlluminationType(imageIndex, channelIndex); 
    1195         if (result != null) return result; 
    1196       } 
    1197     } 
    1198     return null; 
    1199   } 
    1200  
    1201   /* @see MetadataRetrieve#getChannelLightSourceSettingsAttenuation(int, int) */ 
    1202   public PercentFraction getChannelLightSourceSettingsAttenuation(int imageIndex, int channelIndex) { 
    1203     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    1204       Object o = iter.next(); 
    1205       if (o instanceof MetadataRetrieve) { 
    1206         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    1207         PercentFraction result = retrieve.getChannelLightSourceSettingsAttenuation(imageIndex, channelIndex); 
    1208         if (result != null) return result; 
    1209       } 
    1210     } 
    1211     return null; 
    1212   } 
    1213  
    1214   /* @see MetadataRetrieve#getChannelLightSourceSettingsID(int, int) */ 
    1215   public String getChannelLightSourceSettingsID(int imageIndex, int channelIndex) { 
    1216     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    1217       Object o = iter.next(); 
    1218       if (o instanceof MetadataRetrieve) { 
    1219         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    1220         String result = retrieve.getChannelLightSourceSettingsID(imageIndex, channelIndex); 
    1221         if (result != null) return result; 
    1222       } 
    1223     } 
    1224     return null; 
    1225   } 
    1226  
    1227   /* @see MetadataRetrieve#getChannelLightSourceSettingsWavelength(int, int) */ 
    1228   public PositiveInteger getChannelLightSourceSettingsWavelength(int imageIndex, int channelIndex) { 
    1229     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    1230       Object o = iter.next(); 
    1231       if (o instanceof MetadataRetrieve) { 
    1232         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    1233         PositiveInteger result = retrieve.getChannelLightSourceSettingsWavelength(imageIndex, channelIndex); 
    1234         if (result != null) return result; 
    1235       } 
    1236     } 
    1237     return null; 
    1238   } 
    1239  
    1240   /* @see MetadataRetrieve#getChannelNDFilter(int, int) */ 
    1241   public Double getChannelNDFilter(int imageIndex, int channelIndex) { 
    1242     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    1243       Object o = iter.next(); 
    1244       if (o instanceof MetadataRetrieve) { 
    1245         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    1246         Double result = retrieve.getChannelNDFilter(imageIndex, channelIndex); 
    1247         if (result != null) return result; 
    1248       } 
    1249     } 
    1250     return null; 
    1251   } 
    1252  
    1253   /* @see MetadataRetrieve#getChannelName(int, int) */ 
    1254   public String getChannelName(int imageIndex, int channelIndex) { 
    1255     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    1256       Object o = iter.next(); 
    1257       if (o instanceof MetadataRetrieve) { 
    1258         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    1259         String result = retrieve.getChannelName(imageIndex, channelIndex); 
    1260         if (result != null) return result; 
    1261       } 
    1262     } 
    1263     return null; 
    1264   } 
    1265  
    1266   /* @see MetadataRetrieve#getChannelOTFRef(int, int) */ 
    1267   public String getChannelOTFRef(int imageIndex, int channelIndex) { 
    1268     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    1269       Object o = iter.next(); 
    1270       if (o instanceof MetadataRetrieve) { 
    1271         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    1272         String result = retrieve.getChannelOTFRef(imageIndex, channelIndex); 
    1273         if (result != null) return result; 
    1274       } 
    1275     } 
    1276     return null; 
    1277   } 
    1278  
    1279   /* @see MetadataRetrieve#getChannelPinholeSize(int, int) */ 
    1280   public Double getChannelPinholeSize(int imageIndex, int channelIndex) { 
    1281     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    1282       Object o = iter.next(); 
    1283       if (o instanceof MetadataRetrieve) { 
    1284         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    1285         Double result = retrieve.getChannelPinholeSize(imageIndex, channelIndex); 
    1286         if (result != null) return result; 
    1287       } 
    1288     } 
    1289     return null; 
    1290   } 
    1291  
    1292   /* @see MetadataRetrieve#getChannelPockelCellSetting(int, int) */ 
    1293   public Integer getChannelPockelCellSetting(int imageIndex, int channelIndex) { 
    1294     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    1295       Object o = iter.next(); 
    1296       if (o instanceof MetadataRetrieve) { 
    1297         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    1298         Integer result = retrieve.getChannelPockelCellSetting(imageIndex, channelIndex); 
    1299         if (result != null) return result; 
    1300       } 
    1301     } 
    1302     return null; 
    1303   } 
    1304  
    1305   /* @see MetadataRetrieve#getChannelSamplesPerPixel(int, int) */ 
    1306   public Integer getChannelSamplesPerPixel(int imageIndex, int channelIndex) { 
    1307     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    1308       Object o = iter.next(); 
    1309       if (o instanceof MetadataRetrieve) { 
    1310         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    1311         Integer result = retrieve.getChannelSamplesPerPixel(imageIndex, channelIndex); 
    1312         if (result != null) return result; 
    1313       } 
    1314     } 
    1315     return null; 
    1316   } 
    1317  
    1318   // - ChannelAnnotationRef property retrieval - 
    1319  
    1320   // - Dataset property retrieval - 
    1321  
    1322   /* @see MetadataRetrieve#getDatasetAnnotationRef(int, int) */ 
    1323   public String getDatasetAnnotationRef(int datasetIndex, int annotationRefIndex) { 
    1324     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    1325       Object o = iter.next(); 
    1326       if (o instanceof MetadataRetrieve) { 
    1327         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    1328         String result = retrieve.getDatasetAnnotationRef(datasetIndex, annotationRefIndex); 
    1329         if (result != null) return result; 
    1330       } 
    1331     } 
    1332     return null; 
    1333   } 
    1334  
    1335   /* @see MetadataRetrieve#getDatasetDescription(int) */ 
    1336   public String getDatasetDescription(int datasetIndex) { 
    1337     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    1338       Object o = iter.next(); 
    1339       if (o instanceof MetadataRetrieve) { 
    1340         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    1341         String result = retrieve.getDatasetDescription(datasetIndex); 
    1342         if (result != null) return result; 
    1343       } 
    1344     } 
    1345     return null; 
    1346   } 
    1347  
    1348   /* @see MetadataRetrieve#getDatasetExperimenterRef(int) */ 
    1349   public String getDatasetExperimenterRef(int datasetIndex) { 
    1350     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    1351       Object o = iter.next(); 
    1352       if (o instanceof MetadataRetrieve) { 
    1353         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    1354         String result = retrieve.getDatasetExperimenterRef(datasetIndex); 
    1355         if (result != null) return result; 
    1356       } 
    1357     } 
    1358     return null; 
    1359   } 
    1360  
    1361   /* @see MetadataRetrieve#getDatasetGroupRef(int) */ 
    1362   public String getDatasetGroupRef(int datasetIndex) { 
    1363     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    1364       Object o = iter.next(); 
    1365       if (o instanceof MetadataRetrieve) { 
    1366         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    1367         String result = retrieve.getDatasetGroupRef(datasetIndex); 
    1368         if (result != null) return result; 
    1369       } 
    1370     } 
    1371     return null; 
    1372   } 
    1373  
    1374   /* @see MetadataRetrieve#getDatasetID(int) */ 
    1375   public String getDatasetID(int datasetIndex) { 
    1376     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    1377       Object o = iter.next(); 
    1378       if (o instanceof MetadataRetrieve) { 
    1379         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    1380         String result = retrieve.getDatasetID(datasetIndex); 
    1381         if (result != null) return result; 
    1382       } 
    1383     } 
    1384     return null; 
    1385   } 
    1386  
    1387   /* @see MetadataRetrieve#getDatasetName(int) */ 
    1388   public String getDatasetName(int datasetIndex) { 
    1389     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    1390       Object o = iter.next(); 
    1391       if (o instanceof MetadataRetrieve) { 
    1392         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    1393         String result = retrieve.getDatasetName(datasetIndex); 
    1394         if (result != null) return result; 
    1395       } 
    1396     } 
    1397     return null; 
    1398   } 
    1399  
    1400   /* @see MetadataRetrieve#getDatasetProjectRef(int, int) */ 
    1401   public String getDatasetProjectRef(int datasetIndex, int projectRefIndex) { 
    1402     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    1403       Object o = iter.next(); 
    1404       if (o instanceof MetadataRetrieve) { 
    1405         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    1406         String result = retrieve.getDatasetProjectRef(datasetIndex, projectRefIndex); 
    1407         if (result != null) return result; 
    1408       } 
    1409     } 
    1410     return null; 
    1411   } 
    1412  
    1413   // - DatasetAnnotationRef property retrieval - 
    1414  
    1415   // - DatasetRef property retrieval - 
    1416  
    1417   // - Detector property retrieval - 
    1418  
    1419   /* @see MetadataRetrieve#getDetectorAmplificationGain(int, int) */ 
    1420   public Double getDetectorAmplificationGain(int instrumentIndex, int detectorIndex) { 
    1421     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    1422       Object o = iter.next(); 
    1423       if (o instanceof MetadataRetrieve) { 
    1424         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    1425         Double result = retrieve.getDetectorAmplificationGain(instrumentIndex, detectorIndex); 
    1426         if (result != null) return result; 
    1427       } 
    1428     } 
    1429     return null; 
    1430   } 
    1431  
    1432   /* @see MetadataRetrieve#getDetectorGain(int, int) */ 
    1433   public Double getDetectorGain(int instrumentIndex, int detectorIndex) { 
    1434     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    1435       Object o = iter.next(); 
    1436       if (o instanceof MetadataRetrieve) { 
    1437         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    1438         Double result = retrieve.getDetectorGain(instrumentIndex, detectorIndex); 
    1439         if (result != null) return result; 
    1440       } 
    1441     } 
    1442     return null; 
    1443   } 
    1444  
    1445   /* @see MetadataRetrieve#getDetectorID(int, int) */ 
    1446   public String getDetectorID(int instrumentIndex, int detectorIndex) { 
    1447     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    1448       Object o = iter.next(); 
    1449       if (o instanceof MetadataRetrieve) { 
    1450         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    1451         String result = retrieve.getDetectorID(instrumentIndex, detectorIndex); 
    1452         if (result != null) return result; 
    1453       } 
    1454     } 
    1455     return null; 
    1456   } 
    1457  
    1458   /* @see MetadataRetrieve#getDetectorLotNumber(int, int) */ 
    1459   public String getDetectorLotNumber(int instrumentIndex, int detectorIndex) { 
    1460     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    1461       Object o = iter.next(); 
    1462       if (o instanceof MetadataRetrieve) { 
    1463         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    1464         String result = retrieve.getDetectorLotNumber(instrumentIndex, detectorIndex); 
    1465         if (result != null) return result; 
    1466       } 
    1467     } 
    1468     return null; 
    1469   } 
    1470  
    1471   /* @see MetadataRetrieve#getDetectorManufacturer(int, int) */ 
    1472   public String getDetectorManufacturer(int instrumentIndex, int detectorIndex) { 
    1473     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    1474       Object o = iter.next(); 
    1475       if (o instanceof MetadataRetrieve) { 
    1476         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    1477         String result = retrieve.getDetectorManufacturer(instrumentIndex, detectorIndex); 
    1478         if (result != null) return result; 
    1479       } 
    1480     } 
    1481     return null; 
    1482   } 
    1483  
    1484   /* @see MetadataRetrieve#getDetectorModel(int, int) */ 
    1485   public String getDetectorModel(int instrumentIndex, int detectorIndex) { 
    1486     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    1487       Object o = iter.next(); 
    1488       if (o instanceof MetadataRetrieve) { 
    1489         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    1490         String result = retrieve.getDetectorModel(instrumentIndex, detectorIndex); 
    1491         if (result != null) return result; 
    1492       } 
    1493     } 
    1494     return null; 
    1495   } 
    1496  
    1497   /* @see MetadataRetrieve#getDetectorOffset(int, int) */ 
    1498   public Double getDetectorOffset(int instrumentIndex, int detectorIndex) { 
    1499     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    1500       Object o = iter.next(); 
    1501       if (o instanceof MetadataRetrieve) { 
    1502         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    1503         Double result = retrieve.getDetectorOffset(instrumentIndex, detectorIndex); 
    1504         if (result != null) return result; 
    1505       } 
    1506     } 
    1507     return null; 
    1508   } 
    1509  
    1510   /* @see MetadataRetrieve#getDetectorSerialNumber(int, int) */ 
    1511   public String getDetectorSerialNumber(int instrumentIndex, int detectorIndex) { 
    1512     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    1513       Object o = iter.next(); 
    1514       if (o instanceof MetadataRetrieve) { 
    1515         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    1516         String result = retrieve.getDetectorSerialNumber(instrumentIndex, detectorIndex); 
    1517         if (result != null) return result; 
    1518       } 
    1519     } 
    1520     return null; 
    1521   } 
    1522  
    1523   /* @see MetadataRetrieve#getDetectorType(int, int) */ 
    1524   public DetectorType getDetectorType(int instrumentIndex, int detectorIndex) { 
    1525     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    1526       Object o = iter.next(); 
    1527       if (o instanceof MetadataRetrieve) { 
    1528         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    1529         DetectorType result = retrieve.getDetectorType(instrumentIndex, detectorIndex); 
    1530         if (result != null) return result; 
    1531       } 
    1532     } 
    1533     return null; 
    1534   } 
    1535  
    1536   /* @see MetadataRetrieve#getDetectorVoltage(int, int) */ 
    1537   public Double getDetectorVoltage(int instrumentIndex, int detectorIndex) { 
    1538     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    1539       Object o = iter.next(); 
    1540       if (o instanceof MetadataRetrieve) { 
    1541         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    1542         Double result = retrieve.getDetectorVoltage(instrumentIndex, detectorIndex); 
    1543         if (result != null) return result; 
    1544       } 
    1545     } 
    1546     return null; 
    1547   } 
    1548  
    1549   /* @see MetadataRetrieve#getDetectorZoom(int, int) */ 
    1550   public Double getDetectorZoom(int instrumentIndex, int detectorIndex) { 
    1551     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    1552       Object o = iter.next(); 
    1553       if (o instanceof MetadataRetrieve) { 
    1554         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    1555         Double result = retrieve.getDetectorZoom(instrumentIndex, detectorIndex); 
    1556         if (result != null) return result; 
    1557       } 
    1558     } 
    1559     return null; 
    1560   } 
    1561  
    1562   // - DetectorSettings property retrieval - 
    1563  
    1564   /* @see MetadataRetrieve#getDetectorSettingsBinning(int, int) */ 
    1565   public Binning getDetectorSettingsBinning(int imageIndex, int channelIndex) { 
    1566     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    1567       Object o = iter.next(); 
    1568       if (o instanceof MetadataRetrieve) { 
    1569         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    1570         Binning result = retrieve.getDetectorSettingsBinning(imageIndex, channelIndex); 
    1571         if (result != null) return result; 
    1572       } 
    1573     } 
    1574     return null; 
    1575   } 
    1576  
    1577   /* @see MetadataRetrieve#getDetectorSettingsGain(int, int) */ 
    1578   public Double getDetectorSettingsGain(int imageIndex, int channelIndex) { 
    1579     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    1580       Object o = iter.next(); 
    1581       if (o instanceof MetadataRetrieve) { 
    1582         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    1583         Double result = retrieve.getDetectorSettingsGain(imageIndex, channelIndex); 
    1584         if (result != null) return result; 
    1585       } 
    1586     } 
    1587     return null; 
    1588   } 
    1589  
    1590   /* @see MetadataRetrieve#getDetectorSettingsID(int, int) */ 
    1591   public String getDetectorSettingsID(int imageIndex, int channelIndex) { 
    1592     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    1593       Object o = iter.next(); 
    1594       if (o instanceof MetadataRetrieve) { 
    1595         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    1596         String result = retrieve.getDetectorSettingsID(imageIndex, channelIndex); 
    1597         if (result != null) return result; 
    1598       } 
    1599     } 
    1600     return null; 
    1601   } 
    1602  
    1603   /* @see MetadataRetrieve#getDetectorSettingsOffset(int, int) */ 
    1604   public Double getDetectorSettingsOffset(int imageIndex, int channelIndex) { 
    1605     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    1606       Object o = iter.next(); 
    1607       if (o instanceof MetadataRetrieve) { 
    1608         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    1609         Double result = retrieve.getDetectorSettingsOffset(imageIndex, channelIndex); 
    1610         if (result != null) return result; 
    1611       } 
    1612     } 
    1613     return null; 
    1614   } 
    1615  
    1616   /* @see MetadataRetrieve#getDetectorSettingsReadOutRate(int, int) */ 
    1617   public Double getDetectorSettingsReadOutRate(int imageIndex, int channelIndex) { 
    1618     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    1619       Object o = iter.next(); 
    1620       if (o instanceof MetadataRetrieve) { 
    1621         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    1622         Double result = retrieve.getDetectorSettingsReadOutRate(imageIndex, channelIndex); 
    1623         if (result != null) return result; 
    1624       } 
    1625     } 
    1626     return null; 
    1627   } 
    1628  
    1629   /* @see MetadataRetrieve#getDetectorSettingsVoltage(int, int) */ 
    1630   public Double getDetectorSettingsVoltage(int imageIndex, int channelIndex) { 
    1631     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    1632       Object o = iter.next(); 
    1633       if (o instanceof MetadataRetrieve) { 
    1634         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    1635         Double result = retrieve.getDetectorSettingsVoltage(imageIndex, channelIndex); 
    1636         if (result != null) return result; 
    1637       } 
    1638     } 
    1639     return null; 
    1640   } 
    1641  
    1642   // - Dichroic property retrieval - 
    1643  
    1644   /* @see MetadataRetrieve#getDichroicID(int, int) */ 
    1645   public String getDichroicID(int instrumentIndex, int dichroicIndex) { 
    1646     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    1647       Object o = iter.next(); 
    1648       if (o instanceof MetadataRetrieve) { 
    1649         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    1650         String result = retrieve.getDichroicID(instrumentIndex, dichroicIndex); 
    1651         if (result != null) return result; 
    1652       } 
    1653     } 
    1654     return null; 
    1655   } 
    1656  
    1657   /* @see MetadataRetrieve#getDichroicLotNumber(int, int) */ 
    1658   public String getDichroicLotNumber(int instrumentIndex, int dichroicIndex) { 
    1659     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    1660       Object o = iter.next(); 
    1661       if (o instanceof MetadataRetrieve) { 
    1662         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    1663         String result = retrieve.getDichroicLotNumber(instrumentIndex, dichroicIndex); 
    1664         if (result != null) return result; 
    1665       } 
    1666     } 
    1667     return null; 
    1668   } 
    1669  
    1670   /* @see MetadataRetrieve#getDichroicManufacturer(int, int) */ 
    1671   public String getDichroicManufacturer(int instrumentIndex, int dichroicIndex) { 
    1672     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    1673       Object o = iter.next(); 
    1674       if (o instanceof MetadataRetrieve) { 
    1675         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    1676         String result = retrieve.getDichroicManufacturer(instrumentIndex, dichroicIndex); 
    1677         if (result != null) return result; 
    1678       } 
    1679     } 
    1680     return null; 
    1681   } 
    1682  
    1683   /* @see MetadataRetrieve#getDichroicModel(int, int) */ 
    1684   public String getDichroicModel(int instrumentIndex, int dichroicIndex) { 
    1685     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    1686       Object o = iter.next(); 
    1687       if (o instanceof MetadataRetrieve) { 
    1688         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    1689         String result = retrieve.getDichroicModel(instrumentIndex, dichroicIndex); 
    1690         if (result != null) return result; 
    1691       } 
    1692     } 
    1693     return null; 
    1694   } 
    1695  
    1696   /* @see MetadataRetrieve#getDichroicSerialNumber(int, int) */ 
    1697   public String getDichroicSerialNumber(int instrumentIndex, int dichroicIndex) { 
    1698     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    1699       Object o = iter.next(); 
    1700       if (o instanceof MetadataRetrieve) { 
    1701         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    1702         String result = retrieve.getDichroicSerialNumber(instrumentIndex, dichroicIndex); 
    1703         if (result != null) return result; 
    1704       } 
    1705     } 
    1706     return null; 
    1707   } 
    1708  
    1709   // - DoubleAnnotation property retrieval - 
    1710  
    1711   /* @see MetadataRetrieve#getDoubleAnnotationID(int) */ 
    1712   public String getDoubleAnnotationID(int doubleAnnotationIndex) { 
    1713     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    1714       Object o = iter.next(); 
    1715       if (o instanceof MetadataRetrieve) { 
    1716         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    1717         String result = retrieve.getDoubleAnnotationID(doubleAnnotationIndex); 
    1718         if (result != null) return result; 
    1719       } 
    1720     } 
    1721     return null; 
    1722   } 
    1723  
    1724   /* @see MetadataRetrieve#getDoubleAnnotationNamespace(int) */ 
    1725   public String getDoubleAnnotationNamespace(int doubleAnnotationIndex) { 
    1726     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    1727       Object o = iter.next(); 
    1728       if (o instanceof MetadataRetrieve) { 
    1729         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    1730         String result = retrieve.getDoubleAnnotationNamespace(doubleAnnotationIndex); 
    1731         if (result != null) return result; 
    1732       } 
    1733     } 
    1734     return null; 
    1735   } 
    1736  
    1737   /* @see MetadataRetrieve#getDoubleAnnotationValue(int) */ 
    1738   public Double getDoubleAnnotationValue(int doubleAnnotationIndex) { 
    1739     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    1740       Object o = iter.next(); 
    1741       if (o instanceof MetadataRetrieve) { 
    1742         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    1743         Double result = retrieve.getDoubleAnnotationValue(doubleAnnotationIndex); 
    1744         if (result != null) return result; 
    1745       } 
    1746     } 
    1747     return null; 
    1748   } 
    1749  
    1750   // - Ellipse property retrieval - 
    1751  
    1752   /* @see MetadataRetrieve#getEllipseDescription(int, int) */ 
    1753   public String getEllipseDescription(int roiIndex, int shapeIndex) { 
    1754     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    1755       Object o = iter.next(); 
    1756       if (o instanceof MetadataRetrieve) { 
    1757         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    1758         String result = retrieve.getEllipseDescription(roiIndex, shapeIndex); 
    1759         if (result != null) return result; 
    1760       } 
    1761     } 
    1762     return null; 
    1763   } 
    1764  
    1765   /* @see MetadataRetrieve#getEllipseFill(int, int) */ 
    1766   public Integer getEllipseFill(int roiIndex, int shapeIndex) { 
    1767     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    1768       Object o = iter.next(); 
    1769       if (o instanceof MetadataRetrieve) { 
    1770         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    1771         Integer result = retrieve.getEllipseFill(roiIndex, shapeIndex); 
    1772         if (result != null) return result; 
    1773       } 
    1774     } 
    1775     return null; 
    1776   } 
    1777  
    1778   /* @see MetadataRetrieve#getEllipseFontSize(int, int) */ 
    1779   public Integer getEllipseFontSize(int roiIndex, int shapeIndex) { 
    1780     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    1781       Object o = iter.next(); 
    1782       if (o instanceof MetadataRetrieve) { 
    1783         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    1784         Integer result = retrieve.getEllipseFontSize(roiIndex, shapeIndex); 
    1785         if (result != null) return result; 
    1786       } 
    1787     } 
    1788     return null; 
    1789   } 
    1790  
    1791   /* @see MetadataRetrieve#getEllipseID(int, int) */ 
    1792   public String getEllipseID(int roiIndex, int shapeIndex) { 
    1793     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    1794       Object o = iter.next(); 
    1795       if (o instanceof MetadataRetrieve) { 
    1796         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    1797         String result = retrieve.getEllipseID(roiIndex, shapeIndex); 
    1798         if (result != null) return result; 
    1799       } 
    1800     } 
    1801     return null; 
    1802   } 
    1803  
    1804   /* @see MetadataRetrieve#getEllipseLabel(int, int) */ 
    1805   public String getEllipseLabel(int roiIndex, int shapeIndex) { 
    1806     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    1807       Object o = iter.next(); 
    1808       if (o instanceof MetadataRetrieve) { 
    1809         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    1810         String result = retrieve.getEllipseLabel(roiIndex, shapeIndex); 
    1811         if (result != null) return result; 
    1812       } 
    1813     } 
    1814     return null; 
    1815   } 
    1816  
    1817   /* @see MetadataRetrieve#getEllipseName(int, int) */ 
    1818   public String getEllipseName(int roiIndex, int shapeIndex) { 
    1819     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    1820       Object o = iter.next(); 
    1821       if (o instanceof MetadataRetrieve) { 
    1822         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    1823         String result = retrieve.getEllipseName(roiIndex, shapeIndex); 
    1824         if (result != null) return result; 
    1825       } 
    1826     } 
    1827     return null; 
    1828   } 
    1829  
    1830   /* @see MetadataRetrieve#getEllipseRadiusX(int, int) */ 
    1831   public Double getEllipseRadiusX(int roiIndex, int shapeIndex) { 
    1832     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    1833       Object o = iter.next(); 
    1834       if (o instanceof MetadataRetrieve) { 
    1835         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    1836         Double result = retrieve.getEllipseRadiusX(roiIndex, shapeIndex); 
    1837         if (result != null) return result; 
    1838       } 
    1839     } 
    1840     return null; 
    1841   } 
    1842  
    1843   /* @see MetadataRetrieve#getEllipseRadiusY(int, int) */ 
    1844   public Double getEllipseRadiusY(int roiIndex, int shapeIndex) { 
    1845     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    1846       Object o = iter.next(); 
    1847       if (o instanceof MetadataRetrieve) { 
    1848         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    1849         Double result = retrieve.getEllipseRadiusY(roiIndex, shapeIndex); 
    1850         if (result != null) return result; 
    1851       } 
    1852     } 
    1853     return null; 
    1854   } 
    1855  
    1856   /* @see MetadataRetrieve#getEllipseStroke(int, int) */ 
    1857   public Integer getEllipseStroke(int roiIndex, int shapeIndex) { 
    1858     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    1859       Object o = iter.next(); 
    1860       if (o instanceof MetadataRetrieve) { 
    1861         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    1862         Integer result = retrieve.getEllipseStroke(roiIndex, shapeIndex); 
    1863         if (result != null) return result; 
    1864       } 
    1865     } 
    1866     return null; 
    1867   } 
    1868  
    1869   /* @see MetadataRetrieve#getEllipseStrokeDashArray(int, int) */ 
    1870   public String getEllipseStrokeDashArray(int roiIndex, int shapeIndex) { 
    1871     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    1872       Object o = iter.next(); 
    1873       if (o instanceof MetadataRetrieve) { 
    1874         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    1875         String result = retrieve.getEllipseStrokeDashArray(roiIndex, shapeIndex); 
    1876         if (result != null) return result; 
    1877       } 
    1878     } 
    1879     return null; 
    1880   } 
    1881  
    1882   /* @see MetadataRetrieve#getEllipseStrokeWidth(int, int) */ 
    1883   public Double getEllipseStrokeWidth(int roiIndex, int shapeIndex) { 
    1884     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    1885       Object o = iter.next(); 
    1886       if (o instanceof MetadataRetrieve) { 
    1887         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    1888         Double result = retrieve.getEllipseStrokeWidth(roiIndex, shapeIndex); 
    1889         if (result != null) return result; 
    1890       } 
    1891     } 
    1892     return null; 
    1893   } 
    1894  
    1895   /* @see MetadataRetrieve#getEllipseTheC(int, int) */ 
    1896   public Integer getEllipseTheC(int roiIndex, int shapeIndex) { 
    1897     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    1898       Object o = iter.next(); 
    1899       if (o instanceof MetadataRetrieve) { 
    1900         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    1901         Integer result = retrieve.getEllipseTheC(roiIndex, shapeIndex); 
    1902         if (result != null) return result; 
    1903       } 
    1904     } 
    1905     return null; 
    1906   } 
    1907  
    1908   /* @see MetadataRetrieve#getEllipseTheT(int, int) */ 
    1909   public Integer getEllipseTheT(int roiIndex, int shapeIndex) { 
    1910     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    1911       Object o = iter.next(); 
    1912       if (o instanceof MetadataRetrieve) { 
    1913         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    1914         Integer result = retrieve.getEllipseTheT(roiIndex, shapeIndex); 
    1915         if (result != null) return result; 
    1916       } 
    1917     } 
    1918     return null; 
    1919   } 
    1920  
    1921   /* @see MetadataRetrieve#getEllipseTheZ(int, int) */ 
    1922   public Integer getEllipseTheZ(int roiIndex, int shapeIndex) { 
    1923     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    1924       Object o = iter.next(); 
    1925       if (o instanceof MetadataRetrieve) { 
    1926         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    1927         Integer result = retrieve.getEllipseTheZ(roiIndex, shapeIndex); 
    1928         if (result != null) return result; 
    1929       } 
    1930     } 
    1931     return null; 
    1932   } 
    1933  
    1934   /* @see MetadataRetrieve#getEllipseTransform(int, int) */ 
    1935   public String getEllipseTransform(int roiIndex, int shapeIndex) { 
    1936     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    1937       Object o = iter.next(); 
    1938       if (o instanceof MetadataRetrieve) { 
    1939         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    1940         String result = retrieve.getEllipseTransform(roiIndex, shapeIndex); 
    1941         if (result != null) return result; 
    1942       } 
    1943     } 
    1944     return null; 
    1945   } 
    1946  
    1947   /* @see MetadataRetrieve#getEllipseX(int, int) */ 
    1948   public Double getEllipseX(int roiIndex, int shapeIndex) { 
    1949     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    1950       Object o = iter.next(); 
    1951       if (o instanceof MetadataRetrieve) { 
    1952         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    1953         Double result = retrieve.getEllipseX(roiIndex, shapeIndex); 
    1954         if (result != null) return result; 
    1955       } 
    1956     } 
    1957     return null; 
    1958   } 
    1959  
    1960   /* @see MetadataRetrieve#getEllipseY(int, int) */ 
    1961   public Double getEllipseY(int roiIndex, int shapeIndex) { 
    1962     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    1963       Object o = iter.next(); 
    1964       if (o instanceof MetadataRetrieve) { 
    1965         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    1966         Double result = retrieve.getEllipseY(roiIndex, shapeIndex); 
    1967         if (result != null) return result; 
    1968       } 
    1969     } 
    1970     return null; 
    1971   } 
    1972  
    1973   // - Experiment property retrieval - 
    1974  
    1975   /* @see MetadataRetrieve#getExperimentDescription(int) */ 
    1976   public String getExperimentDescription(int experimentIndex) { 
    1977     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    1978       Object o = iter.next(); 
    1979       if (o instanceof MetadataRetrieve) { 
    1980         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    1981         String result = retrieve.getExperimentDescription(experimentIndex); 
    1982         if (result != null) return result; 
    1983       } 
    1984     } 
    1985     return null; 
    1986   } 
    1987  
    1988   /* @see MetadataRetrieve#getExperimentExperimenterRef(int) */ 
    1989   public String getExperimentExperimenterRef(int experimentIndex) { 
    1990     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    1991       Object o = iter.next(); 
    1992       if (o instanceof MetadataRetrieve) { 
    1993         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    1994         String result = retrieve.getExperimentExperimenterRef(experimentIndex); 
    1995         if (result != null) return result; 
    1996       } 
    1997     } 
    1998     return null; 
    1999   } 
    2000  
    2001   /* @see MetadataRetrieve#getExperimentID(int) */ 
    2002   public String getExperimentID(int experimentIndex) { 
    2003     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    2004       Object o = iter.next(); 
    2005       if (o instanceof MetadataRetrieve) { 
    2006         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    2007         String result = retrieve.getExperimentID(experimentIndex); 
    2008         if (result != null) return result; 
    2009       } 
    2010     } 
    2011     return null; 
    2012   } 
    2013  
    2014   /* @see MetadataRetrieve#getExperimentType(int) */ 
    2015   public ExperimentType getExperimentType(int experimentIndex) { 
    2016     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    2017       Object o = iter.next(); 
    2018       if (o instanceof MetadataRetrieve) { 
    2019         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    2020         ExperimentType result = retrieve.getExperimentType(experimentIndex); 
    2021         if (result != null) return result; 
    2022       } 
    2023     } 
    2024     return null; 
    2025   } 
    2026  
    2027   // - Experimenter property retrieval - 
    2028  
    2029   /* @see MetadataRetrieve#getExperimenterAnnotationRef(int, int) */ 
    2030   public String getExperimenterAnnotationRef(int experimenterIndex, int annotationRefIndex) { 
    2031     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    2032       Object o = iter.next(); 
    2033       if (o instanceof MetadataRetrieve) { 
    2034         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    2035         String result = retrieve.getExperimenterAnnotationRef(experimenterIndex, annotationRefIndex); 
    2036         if (result != null) return result; 
    2037       } 
    2038     } 
    2039     return null; 
    2040   } 
    2041  
    2042   /* @see MetadataRetrieve#getExperimenterDisplayName(int) */ 
    2043   public String getExperimenterDisplayName(int experimenterIndex) { 
    2044     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    2045       Object o = iter.next(); 
    2046       if (o instanceof MetadataRetrieve) { 
    2047         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    2048         String result = retrieve.getExperimenterDisplayName(experimenterIndex); 
    2049         if (result != null) return result; 
    2050       } 
    2051     } 
    2052     return null; 
    2053   } 
    2054  
    2055   /* @see MetadataRetrieve#getExperimenterEmail(int) */ 
    2056   public String getExperimenterEmail(int experimenterIndex) { 
    2057     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    2058       Object o = iter.next(); 
    2059       if (o instanceof MetadataRetrieve) { 
    2060         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    2061         String result = retrieve.getExperimenterEmail(experimenterIndex); 
    2062         if (result != null) return result; 
    2063       } 
    2064     } 
    2065     return null; 
    2066   } 
    2067  
    2068   /* @see MetadataRetrieve#getExperimenterFirstName(int) */ 
    2069   public String getExperimenterFirstName(int experimenterIndex) { 
    2070     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    2071       Object o = iter.next(); 
    2072       if (o instanceof MetadataRetrieve) { 
    2073         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    2074         String result = retrieve.getExperimenterFirstName(experimenterIndex); 
    2075         if (result != null) return result; 
    2076       } 
    2077     } 
    2078     return null; 
    2079   } 
    2080  
    2081   /* @see MetadataRetrieve#getExperimenterGroupRef(int, int) */ 
    2082   public String getExperimenterGroupRef(int experimenterIndex, int groupRefIndex) { 
    2083     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    2084       Object o = iter.next(); 
    2085       if (o instanceof MetadataRetrieve) { 
    2086         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    2087         String result = retrieve.getExperimenterGroupRef(experimenterIndex, groupRefIndex); 
    2088         if (result != null) return result; 
    2089       } 
    2090     } 
    2091     return null; 
    2092   } 
    2093  
    2094   /* @see MetadataRetrieve#getExperimenterID(int) */ 
    2095   public String getExperimenterID(int experimenterIndex) { 
    2096     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    2097       Object o = iter.next(); 
    2098       if (o instanceof MetadataRetrieve) { 
    2099         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    2100         String result = retrieve.getExperimenterID(experimenterIndex); 
    2101         if (result != null) return result; 
    2102       } 
    2103     } 
    2104     return null; 
    2105   } 
    2106  
    2107   /* @see MetadataRetrieve#getExperimenterInstitution(int) */ 
    2108   public String getExperimenterInstitution(int experimenterIndex) { 
    2109     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    2110       Object o = iter.next(); 
    2111       if (o instanceof MetadataRetrieve) { 
    2112         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    2113         String result = retrieve.getExperimenterInstitution(experimenterIndex); 
    2114         if (result != null) return result; 
    2115       } 
    2116     } 
    2117     return null; 
    2118   } 
    2119  
    2120   /* @see MetadataRetrieve#getExperimenterLastName(int) */ 
    2121   public String getExperimenterLastName(int experimenterIndex) { 
    2122     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    2123       Object o = iter.next(); 
    2124       if (o instanceof MetadataRetrieve) { 
    2125         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    2126         String result = retrieve.getExperimenterLastName(experimenterIndex); 
    2127         if (result != null) return result; 
    2128       } 
    2129     } 
    2130     return null; 
    2131   } 
    2132  
    2133   /* @see MetadataRetrieve#getExperimenterMiddleName(int) */ 
    2134   public String getExperimenterMiddleName(int experimenterIndex) { 
    2135     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    2136       Object o = iter.next(); 
    2137       if (o instanceof MetadataRetrieve) { 
    2138         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    2139         String result = retrieve.getExperimenterMiddleName(experimenterIndex); 
    2140         if (result != null) return result; 
    2141       } 
    2142     } 
    2143     return null; 
    2144   } 
    2145  
    2146   /* @see MetadataRetrieve#getExperimenterUserName(int) */ 
    2147   public String getExperimenterUserName(int experimenterIndex) { 
    2148     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    2149       Object o = iter.next(); 
    2150       if (o instanceof MetadataRetrieve) { 
    2151         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    2152         String result = retrieve.getExperimenterUserName(experimenterIndex); 
    2153         if (result != null) return result; 
    2154       } 
    2155     } 
    2156     return null; 
    2157   } 
    2158  
    2159   // - ExperimenterAnnotationRef property retrieval - 
    2160  
    2161   // - ExperimenterGroupRef property retrieval - 
    2162  
    2163   // - Filament property retrieval - 
    2164  
    2165   /* @see MetadataRetrieve#getFilamentID(int, int) */ 
    2166   public String getFilamentID(int instrumentIndex, int filamentIndex) { 
    2167     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    2168       Object o = iter.next(); 
    2169       if (o instanceof MetadataRetrieve) { 
    2170         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    2171         String result = retrieve.getFilamentID(instrumentIndex, filamentIndex); 
    2172         if (result != null) return result; 
    2173       } 
    2174     } 
    2175     return null; 
    2176   } 
    2177  
    2178   /* @see MetadataRetrieve#getFilamentLotNumber(int, int) */ 
    2179   public String getFilamentLotNumber(int instrumentIndex, int filamentIndex) { 
    2180     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    2181       Object o = iter.next(); 
    2182       if (o instanceof MetadataRetrieve) { 
    2183         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    2184         String result = retrieve.getFilamentLotNumber(instrumentIndex, filamentIndex); 
    2185         if (result != null) return result; 
    2186       } 
    2187     } 
    2188     return null; 
    2189   } 
    2190  
    2191   /* @see MetadataRetrieve#getFilamentManufacturer(int, int) */ 
    2192   public String getFilamentManufacturer(int instrumentIndex, int filamentIndex) { 
    2193     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    2194       Object o = iter.next(); 
    2195       if (o instanceof MetadataRetrieve) { 
    2196         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    2197         String result = retrieve.getFilamentManufacturer(instrumentIndex, filamentIndex); 
    2198         if (result != null) return result; 
    2199       } 
    2200     } 
    2201     return null; 
    2202   } 
    2203  
    2204   /* @see MetadataRetrieve#getFilamentModel(int, int) */ 
    2205   public String getFilamentModel(int instrumentIndex, int filamentIndex) { 
    2206     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    2207       Object o = iter.next(); 
    2208       if (o instanceof MetadataRetrieve) { 
    2209         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    2210         String result = retrieve.getFilamentModel(instrumentIndex, filamentIndex); 
    2211         if (result != null) return result; 
    2212       } 
    2213     } 
    2214     return null; 
    2215   } 
    2216  
    2217   /* @see MetadataRetrieve#getFilamentPower(int, int) */ 
    2218   public Double getFilamentPower(int instrumentIndex, int filamentIndex) { 
    2219     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    2220       Object o = iter.next(); 
    2221       if (o instanceof MetadataRetrieve) { 
    2222         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    2223         Double result = retrieve.getFilamentPower(instrumentIndex, filamentIndex); 
    2224         if (result != null) return result; 
    2225       } 
    2226     } 
    2227     return null; 
    2228   } 
    2229  
    2230   /* @see MetadataRetrieve#getFilamentSerialNumber(int, int) */ 
    2231   public String getFilamentSerialNumber(int instrumentIndex, int filamentIndex) { 
    2232     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    2233       Object o = iter.next(); 
    2234       if (o instanceof MetadataRetrieve) { 
    2235         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    2236         String result = retrieve.getFilamentSerialNumber(instrumentIndex, filamentIndex); 
    2237         if (result != null) return result; 
    2238       } 
    2239     } 
    2240     return null; 
    2241   } 
    2242  
    2243   /* @see MetadataRetrieve#getFilamentType(int, int) */ 
    2244   public FilamentType getFilamentType(int instrumentIndex, int filamentIndex) { 
    2245     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    2246       Object o = iter.next(); 
    2247       if (o instanceof MetadataRetrieve) { 
    2248         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    2249         FilamentType result = retrieve.getFilamentType(instrumentIndex, filamentIndex); 
    2250         if (result != null) return result; 
    2251       } 
    2252     } 
    2253     return null; 
    2254   } 
    2255  
    2256   // - FileAnnotation property retrieval - 
    2257  
    2258   /* @see MetadataRetrieve#getFileAnnotationBinaryFileFileName(int) */ 
    2259   public String getFileAnnotationBinaryFileFileName(int fileAnnotationIndex) { 
    2260     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    2261       Object o = iter.next(); 
    2262       if (o instanceof MetadataRetrieve) { 
    2263         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    2264         String result = retrieve.getFileAnnotationBinaryFileFileName(fileAnnotationIndex); 
    2265         if (result != null) return result; 
    2266       } 
    2267     } 
    2268     return null; 
    2269   } 
    2270  
    2271   /* @see MetadataRetrieve#getFileAnnotationBinaryFileMIMEType(int) */ 
    2272   public String getFileAnnotationBinaryFileMIMEType(int fileAnnotationIndex) { 
    2273     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    2274       Object o = iter.next(); 
    2275       if (o instanceof MetadataRetrieve) { 
    2276         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    2277         String result = retrieve.getFileAnnotationBinaryFileMIMEType(fileAnnotationIndex); 
    2278         if (result != null) return result; 
    2279       } 
    2280     } 
    2281     return null; 
    2282   } 
    2283  
    2284   /* @see MetadataRetrieve#getFileAnnotationBinaryFileSize(int) */ 
    2285   public Integer getFileAnnotationBinaryFileSize(int fileAnnotationIndex) { 
    2286     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    2287       Object o = iter.next(); 
    2288       if (o instanceof MetadataRetrieve) { 
    2289         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    2290         Integer result = retrieve.getFileAnnotationBinaryFileSize(fileAnnotationIndex); 
    2291         if (result != null) return result; 
    2292       } 
    2293     } 
    2294     return null; 
    2295   } 
    2296  
    2297   /* @see MetadataRetrieve#getFileAnnotationID(int) */ 
    2298   public String getFileAnnotationID(int fileAnnotationIndex) { 
    2299     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    2300       Object o = iter.next(); 
    2301       if (o instanceof MetadataRetrieve) { 
    2302         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    2303         String result = retrieve.getFileAnnotationID(fileAnnotationIndex); 
    2304         if (result != null) return result; 
    2305       } 
    2306     } 
    2307     return null; 
    2308   } 
    2309  
    2310   /* @see MetadataRetrieve#getFileAnnotationNamespace(int) */ 
    2311   public String getFileAnnotationNamespace(int fileAnnotationIndex) { 
    2312     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    2313       Object o = iter.next(); 
    2314       if (o instanceof MetadataRetrieve) { 
    2315         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    2316         String result = retrieve.getFileAnnotationNamespace(fileAnnotationIndex); 
    2317         if (result != null) return result; 
    2318       } 
    2319     } 
    2320     return null; 
    2321   } 
    2322  
    2323   // - Filter property retrieval - 
    2324  
    2325   /* @see MetadataRetrieve#getFilterFilterWheel(int, int) */ 
    2326   public String getFilterFilterWheel(int instrumentIndex, int filterIndex) { 
    2327     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    2328       Object o = iter.next(); 
    2329       if (o instanceof MetadataRetrieve) { 
    2330         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    2331         String result = retrieve.getFilterFilterWheel(instrumentIndex, filterIndex); 
    2332         if (result != null) return result; 
    2333       } 
    2334     } 
    2335     return null; 
    2336   } 
    2337  
    2338   /* @see MetadataRetrieve#getFilterID(int, int) */ 
    2339   public String getFilterID(int instrumentIndex, int filterIndex) { 
    2340     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    2341       Object o = iter.next(); 
    2342       if (o instanceof MetadataRetrieve) { 
    2343         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    2344         String result = retrieve.getFilterID(instrumentIndex, filterIndex); 
    2345         if (result != null) return result; 
    2346       } 
    2347     } 
    2348     return null; 
    2349   } 
    2350  
    2351   /* @see MetadataRetrieve#getFilterLotNumber(int, int) */ 
    2352   public String getFilterLotNumber(int instrumentIndex, int filterIndex) { 
    2353     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    2354       Object o = iter.next(); 
    2355       if (o instanceof MetadataRetrieve) { 
    2356         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    2357         String result = retrieve.getFilterLotNumber(instrumentIndex, filterIndex); 
    2358         if (result != null) return result; 
    2359       } 
    2360     } 
    2361     return null; 
    2362   } 
    2363  
    2364   /* @see MetadataRetrieve#getFilterManufacturer(int, int) */ 
    2365   public String getFilterManufacturer(int instrumentIndex, int filterIndex) { 
    2366     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    2367       Object o = iter.next(); 
    2368       if (o instanceof MetadataRetrieve) { 
    2369         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    2370         String result = retrieve.getFilterManufacturer(instrumentIndex, filterIndex); 
    2371         if (result != null) return result; 
    2372       } 
    2373     } 
    2374     return null; 
    2375   } 
    2376  
    2377   /* @see MetadataRetrieve#getFilterModel(int, int) */ 
    2378   public String getFilterModel(int instrumentIndex, int filterIndex) { 
    2379     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    2380       Object o = iter.next(); 
    2381       if (o instanceof MetadataRetrieve) { 
    2382         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    2383         String result = retrieve.getFilterModel(instrumentIndex, filterIndex); 
    2384         if (result != null) return result; 
    2385       } 
    2386     } 
    2387     return null; 
    2388   } 
    2389  
    2390   /* @see MetadataRetrieve#getFilterSerialNumber(int, int) */ 
    2391   public String getFilterSerialNumber(int instrumentIndex, int filterIndex) { 
    2392     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    2393       Object o = iter.next(); 
    2394       if (o instanceof MetadataRetrieve) { 
    2395         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    2396         String result = retrieve.getFilterSerialNumber(instrumentIndex, filterIndex); 
    2397         if (result != null) return result; 
    2398       } 
    2399     } 
    2400     return null; 
    2401   } 
    2402  
    2403   /* @see MetadataRetrieve#getFilterType(int, int) */ 
    2404   public FilterType getFilterType(int instrumentIndex, int filterIndex) { 
    2405     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    2406       Object o = iter.next(); 
    2407       if (o instanceof MetadataRetrieve) { 
    2408         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    2409         FilterType result = retrieve.getFilterType(instrumentIndex, filterIndex); 
    2410         if (result != null) return result; 
    2411       } 
    2412     } 
    2413     return null; 
    2414   } 
    2415  
    2416   // - FilterSet property retrieval - 
    2417  
    2418   /* @see MetadataRetrieve#getFilterSetDichroicRef(int, int) */ 
    2419   public String getFilterSetDichroicRef(int instrumentIndex, int filterSetIndex) { 
    2420     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    2421       Object o = iter.next(); 
    2422       if (o instanceof MetadataRetrieve) { 
    2423         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    2424         String result = retrieve.getFilterSetDichroicRef(instrumentIndex, filterSetIndex); 
    2425         if (result != null) return result; 
    2426       } 
    2427     } 
    2428     return null; 
    2429   } 
    2430  
    2431   /* @see MetadataRetrieve#getFilterSetEmissionFilterRef(int, int, int) */ 
    2432   public String getFilterSetEmissionFilterRef(int instrumentIndex, int filterSetIndex, int emissionFilterRefIndex) { 
    2433     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    2434       Object o = iter.next(); 
    2435       if (o instanceof MetadataRetrieve) { 
    2436         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    2437         String result = retrieve.getFilterSetEmissionFilterRef(instrumentIndex, filterSetIndex, emissionFilterRefIndex); 
    2438         if (result != null) return result; 
    2439       } 
    2440     } 
    2441     return null; 
    2442   } 
    2443  
    2444   /* @see MetadataRetrieve#getFilterSetExcitationFilterRef(int, int, int) */ 
    2445   public String getFilterSetExcitationFilterRef(int instrumentIndex, int filterSetIndex, int excitationFilterRefIndex) { 
    2446     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    2447       Object o = iter.next(); 
    2448       if (o instanceof MetadataRetrieve) { 
    2449         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    2450         String result = retrieve.getFilterSetExcitationFilterRef(instrumentIndex, filterSetIndex, excitationFilterRefIndex); 
    2451         if (result != null) return result; 
    2452       } 
    2453     } 
    2454     return null; 
    2455   } 
    2456  
    2457   /* @see MetadataRetrieve#getFilterSetID(int, int) */ 
    2458   public String getFilterSetID(int instrumentIndex, int filterSetIndex) { 
    2459     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    2460       Object o = iter.next(); 
    2461       if (o instanceof MetadataRetrieve) { 
    2462         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    2463         String result = retrieve.getFilterSetID(instrumentIndex, filterSetIndex); 
    2464         if (result != null) return result; 
    2465       } 
    2466     } 
    2467     return null; 
    2468   } 
    2469  
    2470   /* @see MetadataRetrieve#getFilterSetLotNumber(int, int) */ 
    2471   public String getFilterSetLotNumber(int instrumentIndex, int filterSetIndex) { 
    2472     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    2473       Object o = iter.next(); 
    2474       if (o instanceof MetadataRetrieve) { 
    2475         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    2476         String result = retrieve.getFilterSetLotNumber(instrumentIndex, filterSetIndex); 
    2477         if (result != null) return result; 
    2478       } 
    2479     } 
    2480     return null; 
    2481   } 
    2482  
    2483   /* @see MetadataRetrieve#getFilterSetManufacturer(int, int) */ 
    2484   public String getFilterSetManufacturer(int instrumentIndex, int filterSetIndex) { 
    2485     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    2486       Object o = iter.next(); 
    2487       if (o instanceof MetadataRetrieve) { 
    2488         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    2489         String result = retrieve.getFilterSetManufacturer(instrumentIndex, filterSetIndex); 
    2490         if (result != null) return result; 
    2491       } 
    2492     } 
    2493     return null; 
    2494   } 
    2495  
    2496   /* @see MetadataRetrieve#getFilterSetModel(int, int) */ 
    2497   public String getFilterSetModel(int instrumentIndex, int filterSetIndex) { 
    2498     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    2499       Object o = iter.next(); 
    2500       if (o instanceof MetadataRetrieve) { 
    2501         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    2502         String result = retrieve.getFilterSetModel(instrumentIndex, filterSetIndex); 
    2503         if (result != null) return result; 
    2504       } 
    2505     } 
    2506     return null; 
    2507   } 
    2508  
    2509   /* @see MetadataRetrieve#getFilterSetSerialNumber(int, int) */ 
    2510   public String getFilterSetSerialNumber(int instrumentIndex, int filterSetIndex) { 
    2511     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    2512       Object o = iter.next(); 
    2513       if (o instanceof MetadataRetrieve) { 
    2514         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    2515         String result = retrieve.getFilterSetSerialNumber(instrumentIndex, filterSetIndex); 
    2516         if (result != null) return result; 
    2517       } 
    2518     } 
    2519     return null; 
    2520   } 
    2521  
    2522   // - FilterSetEmissionFilterRef property retrieval - 
    2523  
    2524   // - FilterSetExcitationFilterRef property retrieval - 
    2525  
    2526   // - Group property retrieval - 
    2527  
    2528   /* @see MetadataRetrieve#getGroupContact(int) */ 
    2529   public String getGroupContact(int groupIndex) { 
    2530     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    2531       Object o = iter.next(); 
    2532       if (o instanceof MetadataRetrieve) { 
    2533         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    2534         String result = retrieve.getGroupContact(groupIndex); 
    2535         if (result != null) return result; 
    2536       } 
    2537     } 
    2538     return null; 
    2539   } 
    2540  
    2541   /* @see MetadataRetrieve#getGroupDescription(int) */ 
    2542   public String getGroupDescription(int groupIndex) { 
    2543     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    2544       Object o = iter.next(); 
    2545       if (o instanceof MetadataRetrieve) { 
    2546         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    2547         String result = retrieve.getGroupDescription(groupIndex); 
    2548         if (result != null) return result; 
    2549       } 
    2550     } 
    2551     return null; 
    2552   } 
    2553  
    2554   /* @see MetadataRetrieve#getGroupID(int) */ 
    2555   public String getGroupID(int groupIndex) { 
    2556     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    2557       Object o = iter.next(); 
    2558       if (o instanceof MetadataRetrieve) { 
    2559         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    2560         String result = retrieve.getGroupID(groupIndex); 
    2561         if (result != null) return result; 
    2562       } 
    2563     } 
    2564     return null; 
    2565   } 
    2566  
    2567   /* @see MetadataRetrieve#getGroupLeader(int) */ 
    2568   public String getGroupLeader(int groupIndex) { 
    2569     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    2570       Object o = iter.next(); 
    2571       if (o instanceof MetadataRetrieve) { 
    2572         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    2573         String result = retrieve.getGroupLeader(groupIndex); 
    2574         if (result != null) return result; 
    2575       } 
    2576     } 
    2577     return null; 
    2578   } 
    2579  
    2580   /* @see MetadataRetrieve#getGroupName(int) */ 
    2581   public String getGroupName(int groupIndex) { 
    2582     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    2583       Object o = iter.next(); 
    2584       if (o instanceof MetadataRetrieve) { 
    2585         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    2586         String result = retrieve.getGroupName(groupIndex); 
    2587         if (result != null) return result; 
    2588       } 
    2589     } 
    2590     return null; 
    2591   } 
    2592  
    2593   // - Image property retrieval - 
    2594  
    2595   /* @see MetadataRetrieve#getImageAcquiredDate(int) */ 
    2596   public String getImageAcquiredDate(int imageIndex) { 
    2597     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    2598       Object o = iter.next(); 
    2599       if (o instanceof MetadataRetrieve) { 
    2600         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    2601         String result = retrieve.getImageAcquiredDate(imageIndex); 
    2602         if (result != null) return result; 
    2603       } 
    2604     } 
    2605     return null; 
    2606   } 
    2607  
    2608   /* @see MetadataRetrieve#getImageAnnotationRef(int, int) */ 
    2609   public String getImageAnnotationRef(int imageIndex, int annotationRefIndex) { 
    2610     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    2611       Object o = iter.next(); 
    2612       if (o instanceof MetadataRetrieve) { 
    2613         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    2614         String result = retrieve.getImageAnnotationRef(imageIndex, annotationRefIndex); 
    2615         if (result != null) return result; 
    2616       } 
    2617     } 
    2618     return null; 
    2619   } 
    2620  
    2621   /* @see MetadataRetrieve#getImageDatasetRef(int, int) */ 
    2622   public String getImageDatasetRef(int imageIndex, int datasetRefIndex) { 
    2623     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    2624       Object o = iter.next(); 
    2625       if (o instanceof MetadataRetrieve) { 
    2626         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    2627         String result = retrieve.getImageDatasetRef(imageIndex, datasetRefIndex); 
    2628         if (result != null) return result; 
    2629       } 
    2630     } 
    2631     return null; 
    2632   } 
    2633  
    2634   /* @see MetadataRetrieve#getImageDescription(int) */ 
    2635   public String getImageDescription(int imageIndex) { 
    2636     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    2637       Object o = iter.next(); 
    2638       if (o instanceof MetadataRetrieve) { 
    2639         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    2640         String result = retrieve.getImageDescription(imageIndex); 
    2641         if (result != null) return result; 
    2642       } 
    2643     } 
    2644     return null; 
    2645   } 
    2646  
    2647   /* @see MetadataRetrieve#getImageExperimentRef(int) */ 
    2648   public String getImageExperimentRef(int imageIndex) { 
    2649     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    2650       Object o = iter.next(); 
    2651       if (o instanceof MetadataRetrieve) { 
    2652         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    2653         String result = retrieve.getImageExperimentRef(imageIndex); 
    2654         if (result != null) return result; 
    2655       } 
    2656     } 
    2657     return null; 
    2658   } 
    2659  
    2660   /* @see MetadataRetrieve#getImageExperimenterRef(int) */ 
    2661   public String getImageExperimenterRef(int imageIndex) { 
    2662     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    2663       Object o = iter.next(); 
    2664       if (o instanceof MetadataRetrieve) { 
    2665         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    2666         String result = retrieve.getImageExperimenterRef(imageIndex); 
    2667         if (result != null) return result; 
    2668       } 
    2669     } 
    2670     return null; 
    2671   } 
    2672  
    2673   /* @see MetadataRetrieve#getImageGroupRef(int) */ 
    2674   public String getImageGroupRef(int imageIndex) { 
    2675     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    2676       Object o = iter.next(); 
    2677       if (o instanceof MetadataRetrieve) { 
    2678         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    2679         String result = retrieve.getImageGroupRef(imageIndex); 
    2680         if (result != null) return result; 
    2681       } 
    2682     } 
    2683     return null; 
    2684   } 
    2685  
    2686   /* @see MetadataRetrieve#getImageID(int) */ 
    2687   public String getImageID(int imageIndex) { 
    2688     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    2689       Object o = iter.next(); 
    2690       if (o instanceof MetadataRetrieve) { 
    2691         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    2692         String result = retrieve.getImageID(imageIndex); 
    2693         if (result != null) return result; 
    2694       } 
    2695     } 
    2696     return null; 
    2697   } 
    2698  
    2699   /* @see MetadataRetrieve#getImageInstrumentRef(int) */ 
    2700   public String getImageInstrumentRef(int imageIndex) { 
    2701     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    2702       Object o = iter.next(); 
    2703       if (o instanceof MetadataRetrieve) { 
    2704         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    2705         String result = retrieve.getImageInstrumentRef(imageIndex); 
    2706         if (result != null) return result; 
    2707       } 
    2708     } 
    2709     return null; 
    2710   } 
    2711  
    2712   /* @see MetadataRetrieve#getImageMicrobeamManipulationRef(int, int) */ 
    2713   public String getImageMicrobeamManipulationRef(int imageIndex, int microbeamManipulationRefIndex) { 
    2714     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    2715       Object o = iter.next(); 
    2716       if (o instanceof MetadataRetrieve) { 
    2717         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    2718         String result = retrieve.getImageMicrobeamManipulationRef(imageIndex, microbeamManipulationRefIndex); 
    2719         if (result != null) return result; 
    2720       } 
    2721     } 
    2722     return null; 
    2723   } 
    2724  
    2725   /* @see MetadataRetrieve#getImageName(int) */ 
    2726   public String getImageName(int imageIndex) { 
    2727     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    2728       Object o = iter.next(); 
    2729       if (o instanceof MetadataRetrieve) { 
    2730         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    2731         String result = retrieve.getImageName(imageIndex); 
    2732         if (result != null) return result; 
    2733       } 
    2734     } 
    2735     return null; 
    2736   } 
    2737  
    2738   /* @see MetadataRetrieve#getImageObjectiveSettingsCorrectionCollar(int) */ 
    2739   public Double getImageObjectiveSettingsCorrectionCollar(int imageIndex) { 
    2740     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    2741       Object o = iter.next(); 
    2742       if (o instanceof MetadataRetrieve) { 
    2743         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    2744         Double result = retrieve.getImageObjectiveSettingsCorrectionCollar(imageIndex); 
    2745         if (result != null) return result; 
    2746       } 
    2747     } 
    2748     return null; 
    2749   } 
    2750  
    2751   /* @see MetadataRetrieve#getImageObjectiveSettingsID(int) */ 
    2752   public String getImageObjectiveSettingsID(int imageIndex) { 
    2753     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    2754       Object o = iter.next(); 
    2755       if (o instanceof MetadataRetrieve) { 
    2756         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    2757         String result = retrieve.getImageObjectiveSettingsID(imageIndex); 
    2758         if (result != null) return result; 
    2759       } 
    2760     } 
    2761     return null; 
    2762   } 
    2763  
    2764   /* @see MetadataRetrieve#getImageObjectiveSettingsMedium(int) */ 
    2765   public Medium getImageObjectiveSettingsMedium(int imageIndex) { 
    2766     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    2767       Object o = iter.next(); 
    2768       if (o instanceof MetadataRetrieve) { 
    2769         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    2770         Medium result = retrieve.getImageObjectiveSettingsMedium(imageIndex); 
    2771         if (result != null) return result; 
    2772       } 
    2773     } 
    2774     return null; 
    2775   } 
    2776  
    2777   /* @see MetadataRetrieve#getImageObjectiveSettingsRefractiveIndex(int) */ 
    2778   public Double getImageObjectiveSettingsRefractiveIndex(int imageIndex) { 
    2779     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    2780       Object o = iter.next(); 
    2781       if (o instanceof MetadataRetrieve) { 
    2782         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    2783         Double result = retrieve.getImageObjectiveSettingsRefractiveIndex(imageIndex); 
    2784         if (result != null) return result; 
    2785       } 
    2786     } 
    2787     return null; 
    2788   } 
    2789  
    2790   /* @see MetadataRetrieve#getImageROIRef(int, int) */ 
    2791   public String getImageROIRef(int imageIndex, int roiRefIndex) { 
    2792     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    2793       Object o = iter.next(); 
    2794       if (o instanceof MetadataRetrieve) { 
    2795         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    2796         String result = retrieve.getImageROIRef(imageIndex, roiRefIndex); 
    2797         if (result != null) return result; 
    2798       } 
    2799     } 
    2800     return null; 
    2801   } 
    2802  
    2803   // - ImageAnnotationRef property retrieval - 
    2804  
    2805   // - ImageROIRef property retrieval - 
    2806  
    2807   // - ImagingEnvironment property retrieval - 
    2808  
    2809   /* @see MetadataRetrieve#getImagingEnvironmentAirPressure(int) */ 
    2810   public Double getImagingEnvironmentAirPressure(int imageIndex) { 
    2811     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    2812       Object o = iter.next(); 
    2813       if (o instanceof MetadataRetrieve) { 
    2814         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    2815         Double result = retrieve.getImagingEnvironmentAirPressure(imageIndex); 
    2816         if (result != null) return result; 
    2817       } 
    2818     } 
    2819     return null; 
    2820   } 
    2821  
    2822   /* @see MetadataRetrieve#getImagingEnvironmentCO2Percent(int) */ 
    2823   public PercentFraction getImagingEnvironmentCO2Percent(int imageIndex) { 
    2824     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    2825       Object o = iter.next(); 
    2826       if (o instanceof MetadataRetrieve) { 
    2827         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    2828         PercentFraction result = retrieve.getImagingEnvironmentCO2Percent(imageIndex); 
    2829         if (result != null) return result; 
    2830       } 
    2831     } 
    2832     return null; 
    2833   } 
    2834  
    2835   /* @see MetadataRetrieve#getImagingEnvironmentHumidity(int) */ 
    2836   public PercentFraction getImagingEnvironmentHumidity(int imageIndex) { 
    2837     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    2838       Object o = iter.next(); 
    2839       if (o instanceof MetadataRetrieve) { 
    2840         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    2841         PercentFraction result = retrieve.getImagingEnvironmentHumidity(imageIndex); 
    2842         if (result != null) return result; 
    2843       } 
    2844     } 
    2845     return null; 
    2846   } 
    2847  
    2848   /* @see MetadataRetrieve#getImagingEnvironmentTemperature(int) */ 
    2849   public Double getImagingEnvironmentTemperature(int imageIndex) { 
    2850     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    2851       Object o = iter.next(); 
    2852       if (o instanceof MetadataRetrieve) { 
    2853         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    2854         Double result = retrieve.getImagingEnvironmentTemperature(imageIndex); 
    2855         if (result != null) return result; 
    2856       } 
    2857     } 
    2858     return null; 
    2859   } 
    2860  
    2861   // - Instrument property retrieval - 
    2862  
    2863   /* @see MetadataRetrieve#getInstrumentID(int) */ 
    2864   public String getInstrumentID(int instrumentIndex) { 
    2865     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    2866       Object o = iter.next(); 
    2867       if (o instanceof MetadataRetrieve) { 
    2868         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    2869         String result = retrieve.getInstrumentID(instrumentIndex); 
    2870         if (result != null) return result; 
    2871       } 
    2872     } 
    2873     return null; 
    2874   } 
    2875  
    2876   // - Laser property retrieval - 
    2877  
    2878   /* @see MetadataRetrieve#getLaserFrequencyMultiplication(int, int) */ 
    2879   public PositiveInteger getLaserFrequencyMultiplication(int instrumentIndex, int laserIndex) { 
    2880     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    2881       Object o = iter.next(); 
    2882       if (o instanceof MetadataRetrieve) { 
    2883         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    2884         PositiveInteger result = retrieve.getLaserFrequencyMultiplication(instrumentIndex, laserIndex); 
    2885         if (result != null) return result; 
    2886       } 
    2887     } 
    2888     return null; 
    2889   } 
    2890  
    2891   /* @see MetadataRetrieve#getLaserID(int, int) */ 
    2892   public String getLaserID(int instrumentIndex, int laserIndex) { 
    2893     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    2894       Object o = iter.next(); 
    2895       if (o instanceof MetadataRetrieve) { 
    2896         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    2897         String result = retrieve.getLaserID(instrumentIndex, laserIndex); 
    2898         if (result != null) return result; 
    2899       } 
    2900     } 
    2901     return null; 
    2902   } 
    2903  
    2904   /* @see MetadataRetrieve#getLaserLaserMedium(int, int) */ 
    2905   public LaserMedium getLaserLaserMedium(int instrumentIndex, int laserIndex) { 
    2906     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    2907       Object o = iter.next(); 
    2908       if (o instanceof MetadataRetrieve) { 
    2909         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    2910         LaserMedium result = retrieve.getLaserLaserMedium(instrumentIndex, laserIndex); 
    2911         if (result != null) return result; 
    2912       } 
    2913     } 
    2914     return null; 
    2915   } 
    2916  
    2917   /* @see MetadataRetrieve#getLaserLotNumber(int, int) */ 
    2918   public String getLaserLotNumber(int instrumentIndex, int laserIndex) { 
    2919     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    2920       Object o = iter.next(); 
    2921       if (o instanceof MetadataRetrieve) { 
    2922         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    2923         String result = retrieve.getLaserLotNumber(instrumentIndex, laserIndex); 
    2924         if (result != null) return result; 
    2925       } 
    2926     } 
    2927     return null; 
    2928   } 
    2929  
    2930   /* @see MetadataRetrieve#getLaserManufacturer(int, int) */ 
    2931   public String getLaserManufacturer(int instrumentIndex, int laserIndex) { 
    2932     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    2933       Object o = iter.next(); 
    2934       if (o instanceof MetadataRetrieve) { 
    2935         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    2936         String result = retrieve.getLaserManufacturer(instrumentIndex, laserIndex); 
    2937         if (result != null) return result; 
    2938       } 
    2939     } 
    2940     return null; 
    2941   } 
    2942  
    2943   /* @see MetadataRetrieve#getLaserModel(int, int) */ 
    2944   public String getLaserModel(int instrumentIndex, int laserIndex) { 
    2945     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    2946       Object o = iter.next(); 
    2947       if (o instanceof MetadataRetrieve) { 
    2948         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    2949         String result = retrieve.getLaserModel(instrumentIndex, laserIndex); 
    2950         if (result != null) return result; 
    2951       } 
    2952     } 
    2953     return null; 
    2954   } 
    2955  
    2956   /* @see MetadataRetrieve#getLaserPockelCell(int, int) */ 
    2957   public Boolean getLaserPockelCell(int instrumentIndex, int laserIndex) { 
    2958     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    2959       Object o = iter.next(); 
    2960       if (o instanceof MetadataRetrieve) { 
    2961         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    2962         Boolean result = retrieve.getLaserPockelCell(instrumentIndex, laserIndex); 
    2963         if (result != null) return result; 
    2964       } 
    2965     } 
    2966     return null; 
    2967   } 
    2968  
    2969   /* @see MetadataRetrieve#getLaserPower(int, int) */ 
    2970   public Double getLaserPower(int instrumentIndex, int laserIndex) { 
    2971     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    2972       Object o = iter.next(); 
    2973       if (o instanceof MetadataRetrieve) { 
    2974         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    2975         Double result = retrieve.getLaserPower(instrumentIndex, laserIndex); 
    2976         if (result != null) return result; 
    2977       } 
    2978     } 
    2979     return null; 
    2980   } 
    2981  
    2982   /* @see MetadataRetrieve#getLaserPulse(int, int) */ 
    2983   public Pulse getLaserPulse(int instrumentIndex, int laserIndex) { 
    2984     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    2985       Object o = iter.next(); 
    2986       if (o instanceof MetadataRetrieve) { 
    2987         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    2988         Pulse result = retrieve.getLaserPulse(instrumentIndex, laserIndex); 
    2989         if (result != null) return result; 
    2990       } 
    2991     } 
    2992     return null; 
    2993   } 
    2994  
    2995   /* @see MetadataRetrieve#getLaserPump(int, int) */ 
    2996   public String getLaserPump(int instrumentIndex, int laserIndex) { 
    2997     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    2998       Object o = iter.next(); 
    2999       if (o instanceof MetadataRetrieve) { 
    3000         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    3001         String result = retrieve.getLaserPump(instrumentIndex, laserIndex); 
    3002         if (result != null) return result; 
    3003       } 
    3004     } 
    3005     return null; 
    3006   } 
    3007  
    3008   /* @see MetadataRetrieve#getLaserRepetitionRate(int, int) */ 
    3009   public Double getLaserRepetitionRate(int instrumentIndex, int laserIndex) { 
    3010     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    3011       Object o = iter.next(); 
    3012       if (o instanceof MetadataRetrieve) { 
    3013         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    3014         Double result = retrieve.getLaserRepetitionRate(instrumentIndex, laserIndex); 
    3015         if (result != null) return result; 
    3016       } 
    3017     } 
    3018     return null; 
    3019   } 
    3020  
    3021   /* @see MetadataRetrieve#getLaserSerialNumber(int, int) */ 
    3022   public String getLaserSerialNumber(int instrumentIndex, int laserIndex) { 
    3023     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    3024       Object o = iter.next(); 
    3025       if (o instanceof MetadataRetrieve) { 
    3026         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    3027         String result = retrieve.getLaserSerialNumber(instrumentIndex, laserIndex); 
    3028         if (result != null) return result; 
    3029       } 
    3030     } 
    3031     return null; 
    3032   } 
    3033  
    3034   /* @see MetadataRetrieve#getLaserTuneable(int, int) */ 
    3035   public Boolean getLaserTuneable(int instrumentIndex, int laserIndex) { 
    3036     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    3037       Object o = iter.next(); 
    3038       if (o instanceof MetadataRetrieve) { 
    3039         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    3040         Boolean result = retrieve.getLaserTuneable(instrumentIndex, laserIndex); 
    3041         if (result != null) return result; 
    3042       } 
    3043     } 
    3044     return null; 
    3045   } 
    3046  
    3047   /* @see MetadataRetrieve#getLaserType(int, int) */ 
    3048   public LaserType getLaserType(int instrumentIndex, int laserIndex) { 
    3049     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    3050       Object o = iter.next(); 
    3051       if (o instanceof MetadataRetrieve) { 
    3052         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    3053         LaserType result = retrieve.getLaserType(instrumentIndex, laserIndex); 
    3054         if (result != null) return result; 
    3055       } 
    3056     } 
    3057     return null; 
    3058   } 
    3059  
    3060   /* @see MetadataRetrieve#getLaserWavelength(int, int) */ 
    3061   public PositiveInteger getLaserWavelength(int instrumentIndex, int laserIndex) { 
    3062     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    3063       Object o = iter.next(); 
    3064       if (o instanceof MetadataRetrieve) { 
    3065         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    3066         PositiveInteger result = retrieve.getLaserWavelength(instrumentIndex, laserIndex); 
    3067         if (result != null) return result; 
    3068       } 
    3069     } 
    3070     return null; 
    3071   } 
    3072  
    3073   // - LightEmittingDiode property retrieval - 
    3074  
    3075   /* @see MetadataRetrieve#getLightEmittingDiodeID(int, int) */ 
    3076   public String getLightEmittingDiodeID(int instrumentIndex, int lightEmittingDiodeIndex) { 
    3077     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    3078       Object o = iter.next(); 
    3079       if (o instanceof MetadataRetrieve) { 
    3080         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    3081         String result = retrieve.getLightEmittingDiodeID(instrumentIndex, lightEmittingDiodeIndex); 
    3082         if (result != null) return result; 
    3083       } 
    3084     } 
    3085     return null; 
    3086   } 
    3087  
    3088   /* @see MetadataRetrieve#getLightEmittingDiodeLotNumber(int, int) */ 
    3089   public String getLightEmittingDiodeLotNumber(int instrumentIndex, int lightEmittingDiodeIndex) { 
    3090     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    3091       Object o = iter.next(); 
    3092       if (o instanceof MetadataRetrieve) { 
    3093         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    3094         String result = retrieve.getLightEmittingDiodeLotNumber(instrumentIndex, lightEmittingDiodeIndex); 
    3095         if (result != null) return result; 
    3096       } 
    3097     } 
    3098     return null; 
    3099   } 
    3100  
    3101   /* @see MetadataRetrieve#getLightEmittingDiodeManufacturer(int, int) */ 
    3102   public String getLightEmittingDiodeManufacturer(int instrumentIndex, int lightEmittingDiodeIndex) { 
    3103     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    3104       Object o = iter.next(); 
    3105       if (o instanceof MetadataRetrieve) { 
    3106         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    3107         String result = retrieve.getLightEmittingDiodeManufacturer(instrumentIndex, lightEmittingDiodeIndex); 
    3108         if (result != null) return result; 
    3109       } 
    3110     } 
    3111     return null; 
    3112   } 
    3113  
    3114   /* @see MetadataRetrieve#getLightEmittingDiodeModel(int, int) */ 
    3115   public String getLightEmittingDiodeModel(int instrumentIndex, int lightEmittingDiodeIndex) { 
    3116     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    3117       Object o = iter.next(); 
    3118       if (o instanceof MetadataRetrieve) { 
    3119         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    3120         String result = retrieve.getLightEmittingDiodeModel(instrumentIndex, lightEmittingDiodeIndex); 
    3121         if (result != null) return result; 
    3122       } 
    3123     } 
    3124     return null; 
    3125   } 
    3126  
    3127   /* @see MetadataRetrieve#getLightEmittingDiodePower(int, int) */ 
    3128   public Double getLightEmittingDiodePower(int instrumentIndex, int lightEmittingDiodeIndex) { 
    3129     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    3130       Object o = iter.next(); 
    3131       if (o instanceof MetadataRetrieve) { 
    3132         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    3133         Double result = retrieve.getLightEmittingDiodePower(instrumentIndex, lightEmittingDiodeIndex); 
    3134         if (result != null) return result; 
    3135       } 
    3136     } 
    3137     return null; 
    3138   } 
    3139  
    3140   /* @see MetadataRetrieve#getLightEmittingDiodeSerialNumber(int, int) */ 
    3141   public String getLightEmittingDiodeSerialNumber(int instrumentIndex, int lightEmittingDiodeIndex) { 
    3142     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    3143       Object o = iter.next(); 
    3144       if (o instanceof MetadataRetrieve) { 
    3145         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    3146         String result = retrieve.getLightEmittingDiodeSerialNumber(instrumentIndex, lightEmittingDiodeIndex); 
    3147         if (result != null) return result; 
    3148       } 
    3149     } 
    3150     return null; 
    3151   } 
    3152  
    3153   // - LightPath property retrieval - 
    3154  
    3155   /* @see MetadataRetrieve#getLightPathDichroicRef(int, int) */ 
    3156   public String getLightPathDichroicRef(int imageIndex, int channelIndex) { 
    3157     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    3158       Object o = iter.next(); 
    3159       if (o instanceof MetadataRetrieve) { 
    3160         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    3161         String result = retrieve.getLightPathDichroicRef(imageIndex, channelIndex); 
    3162         if (result != null) return result; 
    3163       } 
    3164     } 
    3165     return null; 
    3166   } 
    3167  
    3168   /* @see MetadataRetrieve#getLightPathEmissionFilterRef(int, int, int) */ 
    3169   public String getLightPathEmissionFilterRef(int imageIndex, int channelIndex, int emissionFilterRefIndex) { 
    3170     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    3171       Object o = iter.next(); 
    3172       if (o instanceof MetadataRetrieve) { 
    3173         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    3174         String result = retrieve.getLightPathEmissionFilterRef(imageIndex, channelIndex, emissionFilterRefIndex); 
    3175         if (result != null) return result; 
    3176       } 
    3177     } 
    3178     return null; 
    3179   } 
    3180  
    3181   /* @see MetadataRetrieve#getLightPathExcitationFilterRef(int, int, int) */ 
    3182   public String getLightPathExcitationFilterRef(int imageIndex, int channelIndex, int excitationFilterRefIndex) { 
    3183     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    3184       Object o = iter.next(); 
    3185       if (o instanceof MetadataRetrieve) { 
    3186         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    3187         String result = retrieve.getLightPathExcitationFilterRef(imageIndex, channelIndex, excitationFilterRefIndex); 
    3188         if (result != null) return result; 
    3189       } 
    3190     } 
    3191     return null; 
    3192   } 
    3193  
    3194   // - LightPathEmissionFilterRef property retrieval - 
    3195  
    3196   // - LightPathExcitationFilterRef property retrieval - 
    3197  
    3198   // - Line property retrieval - 
    3199  
    3200   /* @see MetadataRetrieve#getLineDescription(int, int) */ 
    3201   public String getLineDescription(int roiIndex, int shapeIndex) { 
    3202     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    3203       Object o = iter.next(); 
    3204       if (o instanceof MetadataRetrieve) { 
    3205         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    3206         String result = retrieve.getLineDescription(roiIndex, shapeIndex); 
    3207         if (result != null) return result; 
    3208       } 
    3209     } 
    3210     return null; 
    3211   } 
    3212  
    3213   /* @see MetadataRetrieve#getLineFill(int, int) */ 
    3214   public Integer getLineFill(int roiIndex, int shapeIndex) { 
    3215     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    3216       Object o = iter.next(); 
    3217       if (o instanceof MetadataRetrieve) { 
    3218         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    3219         Integer result = retrieve.getLineFill(roiIndex, shapeIndex); 
    3220         if (result != null) return result; 
    3221       } 
    3222     } 
    3223     return null; 
    3224   } 
    3225  
    3226   /* @see MetadataRetrieve#getLineFontSize(int, int) */ 
    3227   public Integer getLineFontSize(int roiIndex, int shapeIndex) { 
    3228     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    3229       Object o = iter.next(); 
    3230       if (o instanceof MetadataRetrieve) { 
    3231         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    3232         Integer result = retrieve.getLineFontSize(roiIndex, shapeIndex); 
    3233         if (result != null) return result; 
    3234       } 
    3235     } 
    3236     return null; 
    3237   } 
    3238  
    3239   /* @see MetadataRetrieve#getLineID(int, int) */ 
    3240   public String getLineID(int roiIndex, int shapeIndex) { 
    3241     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    3242       Object o = iter.next(); 
    3243       if (o instanceof MetadataRetrieve) { 
    3244         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    3245         String result = retrieve.getLineID(roiIndex, shapeIndex); 
    3246         if (result != null) return result; 
    3247       } 
    3248     } 
    3249     return null; 
    3250   } 
    3251  
    3252   /* @see MetadataRetrieve#getLineLabel(int, int) */ 
    3253   public String getLineLabel(int roiIndex, int shapeIndex) { 
    3254     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    3255       Object o = iter.next(); 
    3256       if (o instanceof MetadataRetrieve) { 
    3257         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    3258         String result = retrieve.getLineLabel(roiIndex, shapeIndex); 
    3259         if (result != null) return result; 
    3260       } 
    3261     } 
    3262     return null; 
    3263   } 
    3264  
    3265   /* @see MetadataRetrieve#getLineName(int, int) */ 
    3266   public String getLineName(int roiIndex, int shapeIndex) { 
    3267     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    3268       Object o = iter.next(); 
    3269       if (o instanceof MetadataRetrieve) { 
    3270         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    3271         String result = retrieve.getLineName(roiIndex, shapeIndex); 
    3272         if (result != null) return result; 
    3273       } 
    3274     } 
    3275     return null; 
    3276   } 
    3277  
    3278   /* @see MetadataRetrieve#getLineStroke(int, int) */ 
    3279   public Integer getLineStroke(int roiIndex, int shapeIndex) { 
    3280     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    3281       Object o = iter.next(); 
    3282       if (o instanceof MetadataRetrieve) { 
    3283         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    3284         Integer result = retrieve.getLineStroke(roiIndex, shapeIndex); 
    3285         if (result != null) return result; 
    3286       } 
    3287     } 
    3288     return null; 
    3289   } 
    3290  
    3291   /* @see MetadataRetrieve#getLineStrokeDashArray(int, int) */ 
    3292   public String getLineStrokeDashArray(int roiIndex, int shapeIndex) { 
    3293     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    3294       Object o = iter.next(); 
    3295       if (o instanceof MetadataRetrieve) { 
    3296         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    3297         String result = retrieve.getLineStrokeDashArray(roiIndex, shapeIndex); 
    3298         if (result != null) return result; 
    3299       } 
    3300     } 
    3301     return null; 
    3302   } 
    3303  
    3304   /* @see MetadataRetrieve#getLineStrokeWidth(int, int) */ 
    3305   public Double getLineStrokeWidth(int roiIndex, int shapeIndex) { 
    3306     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    3307       Object o = iter.next(); 
    3308       if (o instanceof MetadataRetrieve) { 
    3309         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    3310         Double result = retrieve.getLineStrokeWidth(roiIndex, shapeIndex); 
    3311         if (result != null) return result; 
    3312       } 
    3313     } 
    3314     return null; 
    3315   } 
    3316  
    3317   /* @see MetadataRetrieve#getLineTheC(int, int) */ 
    3318   public Integer getLineTheC(int roiIndex, int shapeIndex) { 
    3319     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    3320       Object o = iter.next(); 
    3321       if (o instanceof MetadataRetrieve) { 
    3322         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    3323         Integer result = retrieve.getLineTheC(roiIndex, shapeIndex); 
    3324         if (result != null) return result; 
    3325       } 
    3326     } 
    3327     return null; 
    3328   } 
    3329  
    3330   /* @see MetadataRetrieve#getLineTheT(int, int) */ 
    3331   public Integer getLineTheT(int roiIndex, int shapeIndex) { 
    3332     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    3333       Object o = iter.next(); 
    3334       if (o instanceof MetadataRetrieve) { 
    3335         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    3336         Integer result = retrieve.getLineTheT(roiIndex, shapeIndex); 
    3337         if (result != null) return result; 
    3338       } 
    3339     } 
    3340     return null; 
    3341   } 
    3342  
    3343   /* @see MetadataRetrieve#getLineTheZ(int, int) */ 
    3344   public Integer getLineTheZ(int roiIndex, int shapeIndex) { 
    3345     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    3346       Object o = iter.next(); 
    3347       if (o instanceof MetadataRetrieve) { 
    3348         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    3349         Integer result = retrieve.getLineTheZ(roiIndex, shapeIndex); 
    3350         if (result != null) return result; 
    3351       } 
    3352     } 
    3353     return null; 
    3354   } 
    3355  
    3356   /* @see MetadataRetrieve#getLineTransform(int, int) */ 
    3357   public String getLineTransform(int roiIndex, int shapeIndex) { 
    3358     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    3359       Object o = iter.next(); 
    3360       if (o instanceof MetadataRetrieve) { 
    3361         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    3362         String result = retrieve.getLineTransform(roiIndex, shapeIndex); 
    3363         if (result != null) return result; 
    3364       } 
    3365     } 
    3366     return null; 
    3367   } 
    3368  
    3369   /* @see MetadataRetrieve#getLineX1(int, int) */ 
    3370   public Double getLineX1(int roiIndex, int shapeIndex) { 
    3371     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    3372       Object o = iter.next(); 
    3373       if (o instanceof MetadataRetrieve) { 
    3374         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    3375         Double result = retrieve.getLineX1(roiIndex, shapeIndex); 
    3376         if (result != null) return result; 
    3377       } 
    3378     } 
    3379     return null; 
    3380   } 
    3381  
    3382   /* @see MetadataRetrieve#getLineX2(int, int) */ 
    3383   public Double getLineX2(int roiIndex, int shapeIndex) { 
    3384     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    3385       Object o = iter.next(); 
    3386       if (o instanceof MetadataRetrieve) { 
    3387         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    3388         Double result = retrieve.getLineX2(roiIndex, shapeIndex); 
    3389         if (result != null) return result; 
    3390       } 
    3391     } 
    3392     return null; 
    3393   } 
    3394  
    3395   /* @see MetadataRetrieve#getLineY1(int, int) */ 
    3396   public Double getLineY1(int roiIndex, int shapeIndex) { 
    3397     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    3398       Object o = iter.next(); 
    3399       if (o instanceof MetadataRetrieve) { 
    3400         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    3401         Double result = retrieve.getLineY1(roiIndex, shapeIndex); 
    3402         if (result != null) return result; 
    3403       } 
    3404     } 
    3405     return null; 
    3406   } 
    3407  
    3408   /* @see MetadataRetrieve#getLineY2(int, int) */ 
    3409   public Double getLineY2(int roiIndex, int shapeIndex) { 
    3410     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    3411       Object o = iter.next(); 
    3412       if (o instanceof MetadataRetrieve) { 
    3413         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    3414         Double result = retrieve.getLineY2(roiIndex, shapeIndex); 
    3415         if (result != null) return result; 
    3416       } 
    3417     } 
    3418     return null; 
    3419   } 
    3420  
    3421   // - ListAnnotation property retrieval - 
    3422  
    3423   /* @see MetadataRetrieve#getListAnnotationAnnotationRef(int, int) */ 
    3424   public String getListAnnotationAnnotationRef(int listAnnotationIndex, int annotationRefIndex) { 
    3425     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    3426       Object o = iter.next(); 
    3427       if (o instanceof MetadataRetrieve) { 
    3428         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    3429         String result = retrieve.getListAnnotationAnnotationRef(listAnnotationIndex, annotationRefIndex); 
    3430         if (result != null) return result; 
    3431       } 
    3432     } 
    3433     return null; 
    3434   } 
    3435  
    3436   /* @see MetadataRetrieve#getListAnnotationID(int) */ 
    3437   public String getListAnnotationID(int listAnnotationIndex) { 
    3438     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    3439       Object o = iter.next(); 
    3440       if (o instanceof MetadataRetrieve) { 
    3441         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    3442         String result = retrieve.getListAnnotationID(listAnnotationIndex); 
    3443         if (result != null) return result; 
    3444       } 
    3445     } 
    3446     return null; 
    3447   } 
    3448  
    3449   /* @see MetadataRetrieve#getListAnnotationNamespace(int) */ 
    3450   public String getListAnnotationNamespace(int listAnnotationIndex) { 
    3451     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    3452       Object o = iter.next(); 
    3453       if (o instanceof MetadataRetrieve) { 
    3454         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    3455         String result = retrieve.getListAnnotationNamespace(listAnnotationIndex); 
    3456         if (result != null) return result; 
    3457       } 
    3458     } 
    3459     return null; 
    3460   } 
    3461  
    3462   // - ListAnnotationAnnotationRef property retrieval - 
    3463  
    3464   // - LongAnnotation property retrieval - 
    3465  
    3466   /* @see MetadataRetrieve#getLongAnnotationID(int) */ 
    3467   public String getLongAnnotationID(int longAnnotationIndex) { 
    3468     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    3469       Object o = iter.next(); 
    3470       if (o instanceof MetadataRetrieve) { 
    3471         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    3472         String result = retrieve.getLongAnnotationID(longAnnotationIndex); 
    3473         if (result != null) return result; 
    3474       } 
    3475     } 
    3476     return null; 
    3477   } 
    3478  
    3479   /* @see MetadataRetrieve#getLongAnnotationNamespace(int) */ 
    3480   public String getLongAnnotationNamespace(int longAnnotationIndex) { 
    3481     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    3482       Object o = iter.next(); 
    3483       if (o instanceof MetadataRetrieve) { 
    3484         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    3485         String result = retrieve.getLongAnnotationNamespace(longAnnotationIndex); 
    3486         if (result != null) return result; 
    3487       } 
    3488     } 
    3489     return null; 
    3490   } 
    3491  
    3492   /* @see MetadataRetrieve#getLongAnnotationValue(int) */ 
    3493   public Long getLongAnnotationValue(int longAnnotationIndex) { 
    3494     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    3495       Object o = iter.next(); 
    3496       if (o instanceof MetadataRetrieve) { 
    3497         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    3498         Long result = retrieve.getLongAnnotationValue(longAnnotationIndex); 
    3499         if (result != null) return result; 
    3500       } 
    3501     } 
    3502     return null; 
    3503   } 
    3504  
    3505   // - Mask property retrieval - 
    3506  
    3507   /* @see MetadataRetrieve#getMaskDescription(int, int) */ 
    3508   public String getMaskDescription(int roiIndex, int shapeIndex) { 
    3509     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    3510       Object o = iter.next(); 
    3511       if (o instanceof MetadataRetrieve) { 
    3512         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    3513         String result = retrieve.getMaskDescription(roiIndex, shapeIndex); 
    3514         if (result != null) return result; 
    3515       } 
    3516     } 
    3517     return null; 
    3518   } 
    3519  
    3520   /* @see MetadataRetrieve#getMaskFill(int, int) */ 
    3521   public Integer getMaskFill(int roiIndex, int shapeIndex) { 
    3522     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    3523       Object o = iter.next(); 
    3524       if (o instanceof MetadataRetrieve) { 
    3525         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    3526         Integer result = retrieve.getMaskFill(roiIndex, shapeIndex); 
    3527         if (result != null) return result; 
    3528       } 
    3529     } 
    3530     return null; 
    3531   } 
    3532  
    3533   /* @see MetadataRetrieve#getMaskFontSize(int, int) */ 
    3534   public Integer getMaskFontSize(int roiIndex, int shapeIndex) { 
    3535     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    3536       Object o = iter.next(); 
    3537       if (o instanceof MetadataRetrieve) { 
    3538         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    3539         Integer result = retrieve.getMaskFontSize(roiIndex, shapeIndex); 
    3540         if (result != null) return result; 
    3541       } 
    3542     } 
    3543     return null; 
    3544   } 
    3545  
    3546   /* @see MetadataRetrieve#getMaskID(int, int) */ 
    3547   public String getMaskID(int roiIndex, int shapeIndex) { 
    3548     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    3549       Object o = iter.next(); 
    3550       if (o instanceof MetadataRetrieve) { 
    3551         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    3552         String result = retrieve.getMaskID(roiIndex, shapeIndex); 
    3553         if (result != null) return result; 
    3554       } 
    3555     } 
    3556     return null; 
    3557   } 
    3558  
    3559   /* @see MetadataRetrieve#getMaskLabel(int, int) */ 
    3560   public String getMaskLabel(int roiIndex, int shapeIndex) { 
    3561     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    3562       Object o = iter.next(); 
    3563       if (o instanceof MetadataRetrieve) { 
    3564         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    3565         String result = retrieve.getMaskLabel(roiIndex, shapeIndex); 
    3566         if (result != null) return result; 
    3567       } 
    3568     } 
    3569     return null; 
    3570   } 
    3571  
    3572   /* @see MetadataRetrieve#getMaskName(int, int) */ 
    3573   public String getMaskName(int roiIndex, int shapeIndex) { 
    3574     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    3575       Object o = iter.next(); 
    3576       if (o instanceof MetadataRetrieve) { 
    3577         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    3578         String result = retrieve.getMaskName(roiIndex, shapeIndex); 
    3579         if (result != null) return result; 
    3580       } 
    3581     } 
    3582     return null; 
    3583   } 
    3584  
    3585   /* @see MetadataRetrieve#getMaskStroke(int, int) */ 
    3586   public Integer getMaskStroke(int roiIndex, int shapeIndex) { 
    3587     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    3588       Object o = iter.next(); 
    3589       if (o instanceof MetadataRetrieve) { 
    3590         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    3591         Integer result = retrieve.getMaskStroke(roiIndex, shapeIndex); 
    3592         if (result != null) return result; 
    3593       } 
    3594     } 
    3595     return null; 
    3596   } 
    3597  
    3598   /* @see MetadataRetrieve#getMaskStrokeDashArray(int, int) */ 
    3599   public String getMaskStrokeDashArray(int roiIndex, int shapeIndex) { 
    3600     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    3601       Object o = iter.next(); 
    3602       if (o instanceof MetadataRetrieve) { 
    3603         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    3604         String result = retrieve.getMaskStrokeDashArray(roiIndex, shapeIndex); 
    3605         if (result != null) return result; 
    3606       } 
    3607     } 
    3608     return null; 
    3609   } 
    3610  
    3611   /* @see MetadataRetrieve#getMaskStrokeWidth(int, int) */ 
    3612   public Double getMaskStrokeWidth(int roiIndex, int shapeIndex) { 
    3613     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    3614       Object o = iter.next(); 
    3615       if (o instanceof MetadataRetrieve) { 
    3616         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    3617         Double result = retrieve.getMaskStrokeWidth(roiIndex, shapeIndex); 
    3618         if (result != null) return result; 
    3619       } 
    3620     } 
    3621     return null; 
    3622   } 
    3623  
    3624   /* @see MetadataRetrieve#getMaskTheC(int, int) */ 
    3625   public Integer getMaskTheC(int roiIndex, int shapeIndex) { 
    3626     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    3627       Object o = iter.next(); 
    3628       if (o instanceof MetadataRetrieve) { 
    3629         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    3630         Integer result = retrieve.getMaskTheC(roiIndex, shapeIndex); 
    3631         if (result != null) return result; 
    3632       } 
    3633     } 
    3634     return null; 
    3635   } 
    3636  
    3637   /* @see MetadataRetrieve#getMaskTheT(int, int) */ 
    3638   public Integer getMaskTheT(int roiIndex, int shapeIndex) { 
    3639     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    3640       Object o = iter.next(); 
    3641       if (o instanceof MetadataRetrieve) { 
    3642         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    3643         Integer result = retrieve.getMaskTheT(roiIndex, shapeIndex); 
    3644         if (result != null) return result; 
    3645       } 
    3646     } 
    3647     return null; 
    3648   } 
    3649  
    3650   /* @see MetadataRetrieve#getMaskTheZ(int, int) */ 
    3651   public Integer getMaskTheZ(int roiIndex, int shapeIndex) { 
    3652     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    3653       Object o = iter.next(); 
    3654       if (o instanceof MetadataRetrieve) { 
    3655         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    3656         Integer result = retrieve.getMaskTheZ(roiIndex, shapeIndex); 
    3657         if (result != null) return result; 
    3658       } 
    3659     } 
    3660     return null; 
    3661   } 
    3662  
    3663   /* @see MetadataRetrieve#getMaskTransform(int, int) */ 
    3664   public String getMaskTransform(int roiIndex, int shapeIndex) { 
    3665     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    3666       Object o = iter.next(); 
    3667       if (o instanceof MetadataRetrieve) { 
    3668         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    3669         String result = retrieve.getMaskTransform(roiIndex, shapeIndex); 
    3670         if (result != null) return result; 
    3671       } 
    3672     } 
    3673     return null; 
    3674   } 
    3675  
    3676   /* @see MetadataRetrieve#getMaskX(int, int) */ 
    3677   public Double getMaskX(int roiIndex, int shapeIndex) { 
    3678     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    3679       Object o = iter.next(); 
    3680       if (o instanceof MetadataRetrieve) { 
    3681         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    3682         Double result = retrieve.getMaskX(roiIndex, shapeIndex); 
    3683         if (result != null) return result; 
    3684       } 
    3685     } 
    3686     return null; 
    3687   } 
    3688  
    3689   /* @see MetadataRetrieve#getMaskY(int, int) */ 
    3690   public Double getMaskY(int roiIndex, int shapeIndex) { 
    3691     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    3692       Object o = iter.next(); 
    3693       if (o instanceof MetadataRetrieve) { 
    3694         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    3695         Double result = retrieve.getMaskY(roiIndex, shapeIndex); 
    3696         if (result != null) return result; 
    3697       } 
    3698     } 
    3699     return null; 
    3700   } 
    3701  
    3702   // - MicrobeamManipulation property retrieval - 
    3703  
    3704   /* @see MetadataRetrieve#getMicrobeamManipulationExperimenterRef(int, int) */ 
    3705   public String getMicrobeamManipulationExperimenterRef(int experimentIndex, int microbeamManipulationIndex) { 
    3706     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    3707       Object o = iter.next(); 
    3708       if (o instanceof MetadataRetrieve) { 
    3709         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    3710         String result = retrieve.getMicrobeamManipulationExperimenterRef(experimentIndex, microbeamManipulationIndex); 
    3711         if (result != null) return result; 
    3712       } 
    3713     } 
    3714     return null; 
    3715   } 
    3716  
    3717   /* @see MetadataRetrieve#getMicrobeamManipulationID(int, int) */ 
    3718   public String getMicrobeamManipulationID(int experimentIndex, int microbeamManipulationIndex) { 
    3719     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    3720       Object o = iter.next(); 
    3721       if (o instanceof MetadataRetrieve) { 
    3722         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    3723         String result = retrieve.getMicrobeamManipulationID(experimentIndex, microbeamManipulationIndex); 
    3724         if (result != null) return result; 
    3725       } 
    3726     } 
    3727     return null; 
    3728   } 
    3729  
    3730   /* @see MetadataRetrieve#getMicrobeamManipulationROIRef(int, int, int) */ 
    3731   public String getMicrobeamManipulationROIRef(int experimentIndex, int microbeamManipulationIndex, int roiRefIndex) { 
    3732     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    3733       Object o = iter.next(); 
    3734       if (o instanceof MetadataRetrieve) { 
    3735         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    3736         String result = retrieve.getMicrobeamManipulationROIRef(experimentIndex, microbeamManipulationIndex, roiRefIndex); 
    3737         if (result != null) return result; 
    3738       } 
    3739     } 
    3740     return null; 
    3741   } 
    3742  
    3743   /* @see MetadataRetrieve#getMicrobeamManipulationType(int, int) */ 
    3744   public MicrobeamManipulationType getMicrobeamManipulationType(int experimentIndex, int microbeamManipulationIndex) { 
    3745     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    3746       Object o = iter.next(); 
    3747       if (o instanceof MetadataRetrieve) { 
    3748         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    3749         MicrobeamManipulationType result = retrieve.getMicrobeamManipulationType(experimentIndex, microbeamManipulationIndex); 
    3750         if (result != null) return result; 
    3751       } 
    3752     } 
    3753     return null; 
    3754   } 
    3755  
    3756   // - MicrobeamManipulationLightSourceSettings property retrieval - 
    3757  
    3758   /* @see MetadataRetrieve#getMicrobeamManipulationLightSourceSettingsAttenuation(int, int, int) */ 
    3759   public PercentFraction getMicrobeamManipulationLightSourceSettingsAttenuation(int experimentIndex, int microbeamManipulationIndex, int lightSourceSettingsIndex) { 
    3760     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    3761       Object o = iter.next(); 
    3762       if (o instanceof MetadataRetrieve) { 
    3763         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    3764         PercentFraction result = retrieve.getMicrobeamManipulationLightSourceSettingsAttenuation(experimentIndex, microbeamManipulationIndex, lightSourceSettingsIndex); 
    3765         if (result != null) return result; 
    3766       } 
    3767     } 
    3768     return null; 
    3769   } 
    3770  
    3771   /* @see MetadataRetrieve#getMicrobeamManipulationLightSourceSettingsID(int, int, int) */ 
    3772   public String getMicrobeamManipulationLightSourceSettingsID(int experimentIndex, int microbeamManipulationIndex, int lightSourceSettingsIndex) { 
    3773     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    3774       Object o = iter.next(); 
    3775       if (o instanceof MetadataRetrieve) { 
    3776         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    3777         String result = retrieve.getMicrobeamManipulationLightSourceSettingsID(experimentIndex, microbeamManipulationIndex, lightSourceSettingsIndex); 
    3778         if (result != null) return result; 
    3779       } 
    3780     } 
    3781     return null; 
    3782   } 
    3783  
    3784   /* @see MetadataRetrieve#getMicrobeamManipulationLightSourceSettingsWavelength(int, int, int) */ 
    3785   public PositiveInteger getMicrobeamManipulationLightSourceSettingsWavelength(int experimentIndex, int microbeamManipulationIndex, int lightSourceSettingsIndex) { 
    3786     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    3787       Object o = iter.next(); 
    3788       if (o instanceof MetadataRetrieve) { 
    3789         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    3790         PositiveInteger result = retrieve.getMicrobeamManipulationLightSourceSettingsWavelength(experimentIndex, microbeamManipulationIndex, lightSourceSettingsIndex); 
    3791         if (result != null) return result; 
    3792       } 
    3793     } 
    3794     return null; 
    3795   } 
    3796  
    3797   // - MicrobeamManipulationROIRef property retrieval - 
    3798  
    3799   // - MicrobeamManipulationRef property retrieval - 
    3800  
    3801   // - Microscope property retrieval - 
    3802  
    3803   /* @see MetadataRetrieve#getMicroscopeLotNumber(int) */ 
    3804   public String getMicroscopeLotNumber(int instrumentIndex) { 
    3805     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    3806       Object o = iter.next(); 
    3807       if (o instanceof MetadataRetrieve) { 
    3808         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    3809         String result = retrieve.getMicroscopeLotNumber(instrumentIndex); 
    3810         if (result != null) return result; 
    3811       } 
    3812     } 
    3813     return null; 
    3814   } 
    3815  
    3816   /* @see MetadataRetrieve#getMicroscopeManufacturer(int) */ 
    3817   public String getMicroscopeManufacturer(int instrumentIndex) { 
    3818     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    3819       Object o = iter.next(); 
    3820       if (o instanceof MetadataRetrieve) { 
    3821         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    3822         String result = retrieve.getMicroscopeManufacturer(instrumentIndex); 
    3823         if (result != null) return result; 
    3824       } 
    3825     } 
    3826     return null; 
    3827   } 
    3828  
    3829   /* @see MetadataRetrieve#getMicroscopeModel(int) */ 
    3830   public String getMicroscopeModel(int instrumentIndex) { 
    3831     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    3832       Object o = iter.next(); 
    3833       if (o instanceof MetadataRetrieve) { 
    3834         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    3835         String result = retrieve.getMicroscopeModel(instrumentIndex); 
    3836         if (result != null) return result; 
    3837       } 
    3838     } 
    3839     return null; 
    3840   } 
    3841  
    3842   /* @see MetadataRetrieve#getMicroscopeSerialNumber(int) */ 
    3843   public String getMicroscopeSerialNumber(int instrumentIndex) { 
    3844     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    3845       Object o = iter.next(); 
    3846       if (o instanceof MetadataRetrieve) { 
    3847         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    3848         String result = retrieve.getMicroscopeSerialNumber(instrumentIndex); 
    3849         if (result != null) return result; 
    3850       } 
    3851     } 
    3852     return null; 
    3853   } 
    3854  
    3855   /* @see MetadataRetrieve#getMicroscopeType(int) */ 
    3856   public MicroscopeType getMicroscopeType(int instrumentIndex) { 
    3857     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    3858       Object o = iter.next(); 
    3859       if (o instanceof MetadataRetrieve) { 
    3860         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    3861         MicroscopeType result = retrieve.getMicroscopeType(instrumentIndex); 
    3862         if (result != null) return result; 
    3863       } 
    3864     } 
    3865     return null; 
    3866   } 
    3867  
    3868   // - OTF property retrieval - 
    3869  
    3870   /* @see MetadataRetrieve#getOTFBinaryFileFileName(int, int) */ 
    3871   public String getOTFBinaryFileFileName(int instrumentIndex, int otfIndex) { 
    3872     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    3873       Object o = iter.next(); 
    3874       if (o instanceof MetadataRetrieve) { 
    3875         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    3876         String result = retrieve.getOTFBinaryFileFileName(instrumentIndex, otfIndex); 
    3877         if (result != null) return result; 
    3878       } 
    3879     } 
    3880     return null; 
    3881   } 
    3882  
    3883   /* @see MetadataRetrieve#getOTFBinaryFileMIMEType(int, int) */ 
    3884   public String getOTFBinaryFileMIMEType(int instrumentIndex, int otfIndex) { 
    3885     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    3886       Object o = iter.next(); 
    3887       if (o instanceof MetadataRetrieve) { 
    3888         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    3889         String result = retrieve.getOTFBinaryFileMIMEType(instrumentIndex, otfIndex); 
    3890         if (result != null) return result; 
    3891       } 
    3892     } 
    3893     return null; 
    3894   } 
    3895  
    3896   /* @see MetadataRetrieve#getOTFBinaryFileSize(int, int) */ 
    3897   public Integer getOTFBinaryFileSize(int instrumentIndex, int otfIndex) { 
    3898     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    3899       Object o = iter.next(); 
    3900       if (o instanceof MetadataRetrieve) { 
    3901         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    3902         Integer result = retrieve.getOTFBinaryFileSize(instrumentIndex, otfIndex); 
    3903         if (result != null) return result; 
    3904       } 
    3905     } 
    3906     return null; 
    3907   } 
    3908  
    3909   /* @see MetadataRetrieve#getOTFFilterSetRef(int, int) */ 
    3910   public String getOTFFilterSetRef(int instrumentIndex, int otfIndex) { 
    3911     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    3912       Object o = iter.next(); 
    3913       if (o instanceof MetadataRetrieve) { 
    3914         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    3915         String result = retrieve.getOTFFilterSetRef(instrumentIndex, otfIndex); 
    3916         if (result != null) return result; 
    3917       } 
    3918     } 
    3919     return null; 
    3920   } 
    3921  
    3922   /* @see MetadataRetrieve#getOTFID(int, int) */ 
    3923   public String getOTFID(int instrumentIndex, int otfIndex) { 
    3924     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    3925       Object o = iter.next(); 
    3926       if (o instanceof MetadataRetrieve) { 
    3927         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    3928         String result = retrieve.getOTFID(instrumentIndex, otfIndex); 
    3929         if (result != null) return result; 
    3930       } 
    3931     } 
    3932     return null; 
    3933   } 
    3934  
    3935   /* @see MetadataRetrieve#getOTFObjectiveSettingsCorrectionCollar(int, int) */ 
    3936   public Double getOTFObjectiveSettingsCorrectionCollar(int instrumentIndex, int otfIndex) { 
    3937     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    3938       Object o = iter.next(); 
    3939       if (o instanceof MetadataRetrieve) { 
    3940         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    3941         Double result = retrieve.getOTFObjectiveSettingsCorrectionCollar(instrumentIndex, otfIndex); 
    3942         if (result != null) return result; 
    3943       } 
    3944     } 
    3945     return null; 
    3946   } 
    3947  
    3948   /* @see MetadataRetrieve#getOTFObjectiveSettingsID(int, int) */ 
    3949   public String getOTFObjectiveSettingsID(int instrumentIndex, int otfIndex) { 
    3950     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    3951       Object o = iter.next(); 
    3952       if (o instanceof MetadataRetrieve) { 
    3953         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    3954         String result = retrieve.getOTFObjectiveSettingsID(instrumentIndex, otfIndex); 
    3955         if (result != null) return result; 
    3956       } 
    3957     } 
    3958     return null; 
    3959   } 
    3960  
    3961   /* @see MetadataRetrieve#getOTFObjectiveSettingsMedium(int, int) */ 
    3962   public Medium getOTFObjectiveSettingsMedium(int instrumentIndex, int otfIndex) { 
    3963     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    3964       Object o = iter.next(); 
    3965       if (o instanceof MetadataRetrieve) { 
    3966         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    3967         Medium result = retrieve.getOTFObjectiveSettingsMedium(instrumentIndex, otfIndex); 
    3968         if (result != null) return result; 
    3969       } 
    3970     } 
    3971     return null; 
    3972   } 
    3973  
    3974   /* @see MetadataRetrieve#getOTFObjectiveSettingsRefractiveIndex(int, int) */ 
    3975   public Double getOTFObjectiveSettingsRefractiveIndex(int instrumentIndex, int otfIndex) { 
    3976     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    3977       Object o = iter.next(); 
    3978       if (o instanceof MetadataRetrieve) { 
    3979         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    3980         Double result = retrieve.getOTFObjectiveSettingsRefractiveIndex(instrumentIndex, otfIndex); 
    3981         if (result != null) return result; 
    3982       } 
    3983     } 
    3984     return null; 
    3985   } 
    3986  
    3987   /* @see MetadataRetrieve#getOTFOpticalAxisAveraged(int, int) */ 
    3988   public Boolean getOTFOpticalAxisAveraged(int instrumentIndex, int otfIndex) { 
    3989     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    3990       Object o = iter.next(); 
    3991       if (o instanceof MetadataRetrieve) { 
    3992         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    3993         Boolean result = retrieve.getOTFOpticalAxisAveraged(instrumentIndex, otfIndex); 
    3994         if (result != null) return result; 
    3995       } 
    3996     } 
    3997     return null; 
    3998   } 
    3999  
    4000   /* @see MetadataRetrieve#getOTFSizeX(int, int) */ 
    4001   public PositiveInteger getOTFSizeX(int instrumentIndex, int otfIndex) { 
    4002     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    4003       Object o = iter.next(); 
    4004       if (o instanceof MetadataRetrieve) { 
    4005         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    4006         PositiveInteger result = retrieve.getOTFSizeX(instrumentIndex, otfIndex); 
    4007         if (result != null) return result; 
    4008       } 
    4009     } 
    4010     return null; 
    4011   } 
    4012  
    4013   /* @see MetadataRetrieve#getOTFSizeY(int, int) */ 
    4014   public PositiveInteger getOTFSizeY(int instrumentIndex, int otfIndex) { 
    4015     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    4016       Object o = iter.next(); 
    4017       if (o instanceof MetadataRetrieve) { 
    4018         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    4019         PositiveInteger result = retrieve.getOTFSizeY(instrumentIndex, otfIndex); 
    4020         if (result != null) return result; 
    4021       } 
    4022     } 
    4023     return null; 
    4024   } 
    4025  
    4026   /* @see MetadataRetrieve#getOTFType(int, int) */ 
    4027   public PixelType getOTFType(int instrumentIndex, int otfIndex) { 
    4028     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    4029       Object o = iter.next(); 
    4030       if (o instanceof MetadataRetrieve) { 
    4031         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    4032         PixelType result = retrieve.getOTFType(instrumentIndex, otfIndex); 
    4033         if (result != null) return result; 
    4034       } 
    4035     } 
    4036     return null; 
    4037   } 
    4038  
    4039   // - Objective property retrieval - 
    4040  
    4041   /* @see MetadataRetrieve#getObjectiveCalibratedMagnification(int, int) */ 
    4042   public Double getObjectiveCalibratedMagnification(int instrumentIndex, int objectiveIndex) { 
    4043     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    4044       Object o = iter.next(); 
    4045       if (o instanceof MetadataRetrieve) { 
    4046         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    4047         Double result = retrieve.getObjectiveCalibratedMagnification(instrumentIndex, objectiveIndex); 
    4048         if (result != null) return result; 
    4049       } 
    4050     } 
    4051     return null; 
    4052   } 
    4053  
    4054   /* @see MetadataRetrieve#getObjectiveCorrection(int, int) */ 
    4055   public Correction getObjectiveCorrection(int instrumentIndex, int objectiveIndex) { 
    4056     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    4057       Object o = iter.next(); 
    4058       if (o instanceof MetadataRetrieve) { 
    4059         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    4060         Correction result = retrieve.getObjectiveCorrection(instrumentIndex, objectiveIndex); 
    4061         if (result != null) return result; 
    4062       } 
    4063     } 
    4064     return null; 
    4065   } 
    4066  
    4067   /* @see MetadataRetrieve#getObjectiveID(int, int) */ 
    4068   public String getObjectiveID(int instrumentIndex, int objectiveIndex) { 
    4069     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    4070       Object o = iter.next(); 
    4071       if (o instanceof MetadataRetrieve) { 
    4072         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    4073         String result = retrieve.getObjectiveID(instrumentIndex, objectiveIndex); 
    4074         if (result != null) return result; 
    4075       } 
    4076     } 
    4077     return null; 
    4078   } 
    4079  
    4080   /* @see MetadataRetrieve#getObjectiveImmersion(int, int) */ 
    4081   public Immersion getObjectiveImmersion(int instrumentIndex, int objectiveIndex) { 
    4082     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    4083       Object o = iter.next(); 
    4084       if (o instanceof MetadataRetrieve) { 
    4085         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    4086         Immersion result = retrieve.getObjectiveImmersion(instrumentIndex, objectiveIndex); 
    4087         if (result != null) return result; 
    4088       } 
    4089     } 
    4090     return null; 
    4091   } 
    4092  
    4093   /* @see MetadataRetrieve#getObjectiveIris(int, int) */ 
    4094   public Boolean getObjectiveIris(int instrumentIndex, int objectiveIndex) { 
    4095     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    4096       Object o = iter.next(); 
    4097       if (o instanceof MetadataRetrieve) { 
    4098         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    4099         Boolean result = retrieve.getObjectiveIris(instrumentIndex, objectiveIndex); 
    4100         if (result != null) return result; 
    4101       } 
    4102     } 
    4103     return null; 
    4104   } 
    4105  
    4106   /* @see MetadataRetrieve#getObjectiveLensNA(int, int) */ 
    4107   public Double getObjectiveLensNA(int instrumentIndex, int objectiveIndex) { 
    4108     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    4109       Object o = iter.next(); 
    4110       if (o instanceof MetadataRetrieve) { 
    4111         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    4112         Double result = retrieve.getObjectiveLensNA(instrumentIndex, objectiveIndex); 
    4113         if (result != null) return result; 
    4114       } 
    4115     } 
    4116     return null; 
    4117   } 
    4118  
    4119   /* @see MetadataRetrieve#getObjectiveLotNumber(int, int) */ 
    4120   public String getObjectiveLotNumber(int instrumentIndex, int objectiveIndex) { 
    4121     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    4122       Object o = iter.next(); 
    4123       if (o instanceof MetadataRetrieve) { 
    4124         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    4125         String result = retrieve.getObjectiveLotNumber(instrumentIndex, objectiveIndex); 
    4126         if (result != null) return result; 
    4127       } 
    4128     } 
    4129     return null; 
    4130   } 
    4131  
    4132   /* @see MetadataRetrieve#getObjectiveManufacturer(int, int) */ 
    4133   public String getObjectiveManufacturer(int instrumentIndex, int objectiveIndex) { 
    4134     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    4135       Object o = iter.next(); 
    4136       if (o instanceof MetadataRetrieve) { 
    4137         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    4138         String result = retrieve.getObjectiveManufacturer(instrumentIndex, objectiveIndex); 
    4139         if (result != null) return result; 
    4140       } 
    4141     } 
    4142     return null; 
    4143   } 
    4144  
    4145   /* @see MetadataRetrieve#getObjectiveModel(int, int) */ 
    4146   public String getObjectiveModel(int instrumentIndex, int objectiveIndex) { 
    4147     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    4148       Object o = iter.next(); 
    4149       if (o instanceof MetadataRetrieve) { 
    4150         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    4151         String result = retrieve.getObjectiveModel(instrumentIndex, objectiveIndex); 
    4152         if (result != null) return result; 
    4153       } 
    4154     } 
    4155     return null; 
    4156   } 
    4157  
    4158   /* @see MetadataRetrieve#getObjectiveNominalMagnification(int, int) */ 
    4159   public Integer getObjectiveNominalMagnification(int instrumentIndex, int objectiveIndex) { 
    4160     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    4161       Object o = iter.next(); 
    4162       if (o instanceof MetadataRetrieve) { 
    4163         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    4164         Integer result = retrieve.getObjectiveNominalMagnification(instrumentIndex, objectiveIndex); 
    4165         if (result != null) return result; 
    4166       } 
    4167     } 
    4168     return null; 
    4169   } 
    4170  
    4171   /* @see MetadataRetrieve#getObjectiveSerialNumber(int, int) */ 
    4172   public String getObjectiveSerialNumber(int instrumentIndex, int objectiveIndex) { 
    4173     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    4174       Object o = iter.next(); 
    4175       if (o instanceof MetadataRetrieve) { 
    4176         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    4177         String result = retrieve.getObjectiveSerialNumber(instrumentIndex, objectiveIndex); 
    4178         if (result != null) return result; 
    4179       } 
    4180     } 
    4181     return null; 
    4182   } 
    4183  
    4184   /* @see MetadataRetrieve#getObjectiveWorkingDistance(int, int) */ 
    4185   public Double getObjectiveWorkingDistance(int instrumentIndex, int objectiveIndex) { 
    4186     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    4187       Object o = iter.next(); 
    4188       if (o instanceof MetadataRetrieve) { 
    4189         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    4190         Double result = retrieve.getObjectiveWorkingDistance(instrumentIndex, objectiveIndex); 
    4191         if (result != null) return result; 
    4192       } 
    4193     } 
    4194     return null; 
    4195   } 
    4196  
    4197   // - Path property retrieval - 
    4198  
    4199   /* @see MetadataRetrieve#getPathDefinition(int, int) */ 
    4200   public String getPathDefinition(int roiIndex, int shapeIndex) { 
    4201     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    4202       Object o = iter.next(); 
    4203       if (o instanceof MetadataRetrieve) { 
    4204         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    4205         String result = retrieve.getPathDefinition(roiIndex, shapeIndex); 
    4206         if (result != null) return result; 
    4207       } 
    4208     } 
    4209     return null; 
    4210   } 
    4211  
    4212   /* @see MetadataRetrieve#getPathDescription(int, int) */ 
    4213   public String getPathDescription(int roiIndex, int shapeIndex) { 
    4214     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    4215       Object o = iter.next(); 
    4216       if (o instanceof MetadataRetrieve) { 
    4217         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    4218         String result = retrieve.getPathDescription(roiIndex, shapeIndex); 
    4219         if (result != null) return result; 
    4220       } 
    4221     } 
    4222     return null; 
    4223   } 
    4224  
    4225   /* @see MetadataRetrieve#getPathFill(int, int) */ 
    4226   public Integer getPathFill(int roiIndex, int shapeIndex) { 
    4227     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    4228       Object o = iter.next(); 
    4229       if (o instanceof MetadataRetrieve) { 
    4230         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    4231         Integer result = retrieve.getPathFill(roiIndex, shapeIndex); 
    4232         if (result != null) return result; 
    4233       } 
    4234     } 
    4235     return null; 
    4236   } 
    4237  
    4238   /* @see MetadataRetrieve#getPathFontSize(int, int) */ 
    4239   public Integer getPathFontSize(int roiIndex, int shapeIndex) { 
    4240     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    4241       Object o = iter.next(); 
    4242       if (o instanceof MetadataRetrieve) { 
    4243         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    4244         Integer result = retrieve.getPathFontSize(roiIndex, shapeIndex); 
    4245         if (result != null) return result; 
    4246       } 
    4247     } 
    4248     return null; 
    4249   } 
    4250  
    4251   /* @see MetadataRetrieve#getPathID(int, int) */ 
    4252   public String getPathID(int roiIndex, int shapeIndex) { 
    4253     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    4254       Object o = iter.next(); 
    4255       if (o instanceof MetadataRetrieve) { 
    4256         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    4257         String result = retrieve.getPathID(roiIndex, shapeIndex); 
    4258         if (result != null) return result; 
    4259       } 
    4260     } 
    4261     return null; 
    4262   } 
    4263  
    4264   /* @see MetadataRetrieve#getPathLabel(int, int) */ 
    4265   public String getPathLabel(int roiIndex, int shapeIndex) { 
    4266     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    4267       Object o = iter.next(); 
    4268       if (o instanceof MetadataRetrieve) { 
    4269         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    4270         String result = retrieve.getPathLabel(roiIndex, shapeIndex); 
    4271         if (result != null) return result; 
    4272       } 
    4273     } 
    4274     return null; 
    4275   } 
    4276  
    4277   /* @see MetadataRetrieve#getPathName(int, int) */ 
    4278   public String getPathName(int roiIndex, int shapeIndex) { 
    4279     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    4280       Object o = iter.next(); 
    4281       if (o instanceof MetadataRetrieve) { 
    4282         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    4283         String result = retrieve.getPathName(roiIndex, shapeIndex); 
    4284         if (result != null) return result; 
    4285       } 
    4286     } 
    4287     return null; 
    4288   } 
    4289  
    4290   /* @see MetadataRetrieve#getPathStroke(int, int) */ 
    4291   public Integer getPathStroke(int roiIndex, int shapeIndex) { 
    4292     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    4293       Object o = iter.next(); 
    4294       if (o instanceof MetadataRetrieve) { 
    4295         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    4296         Integer result = retrieve.getPathStroke(roiIndex, shapeIndex); 
    4297         if (result != null) return result; 
    4298       } 
    4299     } 
    4300     return null; 
    4301   } 
    4302  
    4303   /* @see MetadataRetrieve#getPathStrokeDashArray(int, int) */ 
    4304   public String getPathStrokeDashArray(int roiIndex, int shapeIndex) { 
    4305     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    4306       Object o = iter.next(); 
    4307       if (o instanceof MetadataRetrieve) { 
    4308         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    4309         String result = retrieve.getPathStrokeDashArray(roiIndex, shapeIndex); 
    4310         if (result != null) return result; 
    4311       } 
    4312     } 
    4313     return null; 
    4314   } 
    4315  
    4316   /* @see MetadataRetrieve#getPathStrokeWidth(int, int) */ 
    4317   public Double getPathStrokeWidth(int roiIndex, int shapeIndex) { 
    4318     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    4319       Object o = iter.next(); 
    4320       if (o instanceof MetadataRetrieve) { 
    4321         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    4322         Double result = retrieve.getPathStrokeWidth(roiIndex, shapeIndex); 
    4323         if (result != null) return result; 
    4324       } 
    4325     } 
    4326     return null; 
    4327   } 
    4328  
    4329   /* @see MetadataRetrieve#getPathTheC(int, int) */ 
    4330   public Integer getPathTheC(int roiIndex, int shapeIndex) { 
    4331     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    4332       Object o = iter.next(); 
    4333       if (o instanceof MetadataRetrieve) { 
    4334         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    4335         Integer result = retrieve.getPathTheC(roiIndex, shapeIndex); 
    4336         if (result != null) return result; 
    4337       } 
    4338     } 
    4339     return null; 
    4340   } 
    4341  
    4342   /* @see MetadataRetrieve#getPathTheT(int, int) */ 
    4343   public Integer getPathTheT(int roiIndex, int shapeIndex) { 
    4344     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    4345       Object o = iter.next(); 
    4346       if (o instanceof MetadataRetrieve) { 
    4347         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    4348         Integer result = retrieve.getPathTheT(roiIndex, shapeIndex); 
    4349         if (result != null) return result; 
    4350       } 
    4351     } 
    4352     return null; 
    4353   } 
    4354  
    4355   /* @see MetadataRetrieve#getPathTheZ(int, int) */ 
    4356   public Integer getPathTheZ(int roiIndex, int shapeIndex) { 
    4357     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    4358       Object o = iter.next(); 
    4359       if (o instanceof MetadataRetrieve) { 
    4360         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    4361         Integer result = retrieve.getPathTheZ(roiIndex, shapeIndex); 
    4362         if (result != null) return result; 
    4363       } 
    4364     } 
    4365     return null; 
    4366   } 
    4367  
    4368   /* @see MetadataRetrieve#getPathTransform(int, int) */ 
    4369   public String getPathTransform(int roiIndex, int shapeIndex) { 
    4370     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    4371       Object o = iter.next(); 
    4372       if (o instanceof MetadataRetrieve) { 
    4373         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    4374         String result = retrieve.getPathTransform(roiIndex, shapeIndex); 
    4375         if (result != null) return result; 
    4376       } 
    4377     } 
    4378     return null; 
    4379   } 
    4380  
    4381   // - Pixels property retrieval - 
    4382  
    4383   /* @see MetadataRetrieve#getPixelsAnnotationRef(int, int) */ 
    4384   public String getPixelsAnnotationRef(int imageIndex, int annotationRefIndex) { 
    4385     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    4386       Object o = iter.next(); 
    4387       if (o instanceof MetadataRetrieve) { 
    4388         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    4389         String result = retrieve.getPixelsAnnotationRef(imageIndex, annotationRefIndex); 
    4390         if (result != null) return result; 
    4391       } 
    4392     } 
    4393     return null; 
    4394   } 
    4395  
    4396   /* @see MetadataRetrieve#getPixelsDimensionOrder(int) */ 
    4397   public DimensionOrder getPixelsDimensionOrder(int imageIndex) { 
    4398     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    4399       Object o = iter.next(); 
    4400       if (o instanceof MetadataRetrieve) { 
    4401         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    4402         DimensionOrder result = retrieve.getPixelsDimensionOrder(imageIndex); 
    4403         if (result != null) return result; 
    4404       } 
    4405     } 
    4406     return null; 
    4407   } 
    4408  
    4409   /* @see MetadataRetrieve#getPixelsID(int) */ 
    4410   public String getPixelsID(int imageIndex) { 
    4411     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    4412       Object o = iter.next(); 
    4413       if (o instanceof MetadataRetrieve) { 
    4414         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    4415         String result = retrieve.getPixelsID(imageIndex); 
    4416         if (result != null) return result; 
    4417       } 
    4418     } 
    4419     return null; 
    4420   } 
    4421  
    4422   /* @see MetadataRetrieve#getPixelsPhysicalSizeX(int) */ 
    4423   public Double getPixelsPhysicalSizeX(int imageIndex) { 
    4424     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    4425       Object o = iter.next(); 
    4426       if (o instanceof MetadataRetrieve) { 
    4427         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    4428         Double result = retrieve.getPixelsPhysicalSizeX(imageIndex); 
    4429         if (result != null) return result; 
    4430       } 
    4431     } 
    4432     return null; 
    4433   } 
    4434  
    4435   /* @see MetadataRetrieve#getPixelsPhysicalSizeY(int) */ 
    4436   public Double getPixelsPhysicalSizeY(int imageIndex) { 
    4437     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    4438       Object o = iter.next(); 
    4439       if (o instanceof MetadataRetrieve) { 
    4440         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    4441         Double result = retrieve.getPixelsPhysicalSizeY(imageIndex); 
    4442         if (result != null) return result; 
    4443       } 
    4444     } 
    4445     return null; 
    4446   } 
    4447  
    4448   /* @see MetadataRetrieve#getPixelsPhysicalSizeZ(int) */ 
    4449   public Double getPixelsPhysicalSizeZ(int imageIndex) { 
    4450     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    4451       Object o = iter.next(); 
    4452       if (o instanceof MetadataRetrieve) { 
    4453         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    4454         Double result = retrieve.getPixelsPhysicalSizeZ(imageIndex); 
    4455         if (result != null) return result; 
    4456       } 
    4457     } 
    4458     return null; 
    4459   } 
    4460  
    4461   /* @see MetadataRetrieve#getPixelsSizeC(int) */ 
    4462   public PositiveInteger getPixelsSizeC(int imageIndex) { 
    4463     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    4464       Object o = iter.next(); 
    4465       if (o instanceof MetadataRetrieve) { 
    4466         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    4467         PositiveInteger result = retrieve.getPixelsSizeC(imageIndex); 
    4468         if (result != null) return result; 
    4469       } 
    4470     } 
    4471     return null; 
    4472   } 
    4473  
    4474   /* @see MetadataRetrieve#getPixelsSizeT(int) */ 
    4475   public PositiveInteger getPixelsSizeT(int imageIndex) { 
    4476     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    4477       Object o = iter.next(); 
    4478       if (o instanceof MetadataRetrieve) { 
    4479         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    4480         PositiveInteger result = retrieve.getPixelsSizeT(imageIndex); 
    4481         if (result != null) return result; 
    4482       } 
    4483     } 
    4484     return null; 
    4485   } 
    4486  
    4487   /* @see MetadataRetrieve#getPixelsSizeX(int) */ 
    4488   public PositiveInteger getPixelsSizeX(int imageIndex) { 
    4489     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    4490       Object o = iter.next(); 
    4491       if (o instanceof MetadataRetrieve) { 
    4492         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    4493         PositiveInteger result = retrieve.getPixelsSizeX(imageIndex); 
    4494         if (result != null) return result; 
    4495       } 
    4496     } 
    4497     return null; 
    4498   } 
    4499  
    4500   /* @see MetadataRetrieve#getPixelsSizeY(int) */ 
    4501   public PositiveInteger getPixelsSizeY(int imageIndex) { 
    4502     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    4503       Object o = iter.next(); 
    4504       if (o instanceof MetadataRetrieve) { 
    4505         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    4506         PositiveInteger result = retrieve.getPixelsSizeY(imageIndex); 
    4507         if (result != null) return result; 
    4508       } 
    4509     } 
    4510     return null; 
    4511   } 
    4512  
    4513   /* @see MetadataRetrieve#getPixelsSizeZ(int) */ 
    4514   public PositiveInteger getPixelsSizeZ(int imageIndex) { 
    4515     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    4516       Object o = iter.next(); 
    4517       if (o instanceof MetadataRetrieve) { 
    4518         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    4519         PositiveInteger result = retrieve.getPixelsSizeZ(imageIndex); 
    4520         if (result != null) return result; 
    4521       } 
    4522     } 
    4523     return null; 
    4524   } 
    4525  
    4526   /* @see MetadataRetrieve#getPixelsTimeIncrement(int) */ 
    4527   public Double getPixelsTimeIncrement(int imageIndex) { 
    4528     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    4529       Object o = iter.next(); 
    4530       if (o instanceof MetadataRetrieve) { 
    4531         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    4532         Double result = retrieve.getPixelsTimeIncrement(imageIndex); 
    4533         if (result != null) return result; 
    4534       } 
    4535     } 
    4536     return null; 
    4537   } 
    4538  
    4539   /* @see MetadataRetrieve#getPixelsType(int) */ 
    4540   public PixelType getPixelsType(int imageIndex) { 
    4541     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    4542       Object o = iter.next(); 
    4543       if (o instanceof MetadataRetrieve) { 
    4544         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    4545         PixelType result = retrieve.getPixelsType(imageIndex); 
    4546         if (result != null) return result; 
    4547       } 
    4548     } 
    4549     return null; 
    4550   } 
    4551  
    4552   // - PixelsAnnotationRef property retrieval - 
    4553  
    4554   // - PixelsBinData property retrieval - 
    4555  
    4556   /* @see MetadataRetrieve#getPixelsBinDataBigEndian(int, int) */ 
    4557   public Boolean getPixelsBinDataBigEndian(int imageIndex, int binDataIndex) { 
    4558     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    4559       Object o = iter.next(); 
    4560       if (o instanceof MetadataRetrieve) { 
    4561         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    4562         Boolean result = retrieve.getPixelsBinDataBigEndian(imageIndex, binDataIndex); 
    4563         if (result != null) return result; 
    4564       } 
    4565     } 
    4566     return null; 
    4567   } 
    4568  
    4569   // - Plane property retrieval - 
    4570  
    4571   /* @see MetadataRetrieve#getPlaneAnnotationRef(int, int, int) */ 
    4572   public String getPlaneAnnotationRef(int imageIndex, int planeIndex, int annotationRefIndex) { 
    4573     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    4574       Object o = iter.next(); 
    4575       if (o instanceof MetadataRetrieve) { 
    4576         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    4577         String result = retrieve.getPlaneAnnotationRef(imageIndex, planeIndex, annotationRefIndex); 
    4578         if (result != null) return result; 
    4579       } 
    4580     } 
    4581     return null; 
    4582   } 
    4583  
    4584   /* @see MetadataRetrieve#getPlaneDeltaT(int, int) */ 
    4585   public Double getPlaneDeltaT(int imageIndex, int planeIndex) { 
    4586     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    4587       Object o = iter.next(); 
    4588       if (o instanceof MetadataRetrieve) { 
    4589         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    4590         Double result = retrieve.getPlaneDeltaT(imageIndex, planeIndex); 
    4591         if (result != null) return result; 
    4592       } 
    4593     } 
    4594     return null; 
    4595   } 
    4596  
    4597   /* @see MetadataRetrieve#getPlaneExposureTime(int, int) */ 
    4598   public Double getPlaneExposureTime(int imageIndex, int planeIndex) { 
    4599     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    4600       Object o = iter.next(); 
    4601       if (o instanceof MetadataRetrieve) { 
    4602         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    4603         Double result = retrieve.getPlaneExposureTime(imageIndex, planeIndex); 
    4604         if (result != null) return result; 
    4605       } 
    4606     } 
    4607     return null; 
    4608   } 
    4609  
    4610   /* @see MetadataRetrieve#getPlaneHashSHA1(int, int) */ 
    4611   public String getPlaneHashSHA1(int imageIndex, int planeIndex) { 
    4612     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    4613       Object o = iter.next(); 
    4614       if (o instanceof MetadataRetrieve) { 
    4615         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    4616         String result = retrieve.getPlaneHashSHA1(imageIndex, planeIndex); 
    4617         if (result != null) return result; 
    4618       } 
    4619     } 
    4620     return null; 
    4621   } 
    4622  
    4623   /* @see MetadataRetrieve#getPlanePositionX(int, int) */ 
    4624   public Double getPlanePositionX(int imageIndex, int planeIndex) { 
    4625     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    4626       Object o = iter.next(); 
    4627       if (o instanceof MetadataRetrieve) { 
    4628         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    4629         Double result = retrieve.getPlanePositionX(imageIndex, planeIndex); 
    4630         if (result != null) return result; 
    4631       } 
    4632     } 
    4633     return null; 
    4634   } 
    4635  
    4636   /* @see MetadataRetrieve#getPlanePositionY(int, int) */ 
    4637   public Double getPlanePositionY(int imageIndex, int planeIndex) { 
    4638     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    4639       Object o = iter.next(); 
    4640       if (o instanceof MetadataRetrieve) { 
    4641         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    4642         Double result = retrieve.getPlanePositionY(imageIndex, planeIndex); 
    4643         if (result != null) return result; 
    4644       } 
    4645     } 
    4646     return null; 
    4647   } 
    4648  
    4649   /* @see MetadataRetrieve#getPlanePositionZ(int, int) */ 
    4650   public Double getPlanePositionZ(int imageIndex, int planeIndex) { 
    4651     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    4652       Object o = iter.next(); 
    4653       if (o instanceof MetadataRetrieve) { 
    4654         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    4655         Double result = retrieve.getPlanePositionZ(imageIndex, planeIndex); 
    4656         if (result != null) return result; 
    4657       } 
    4658     } 
    4659     return null; 
    4660   } 
    4661  
    4662   /* @see MetadataRetrieve#getPlaneTheC(int, int) */ 
    4663   public Integer getPlaneTheC(int imageIndex, int planeIndex) { 
    4664     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    4665       Object o = iter.next(); 
    4666       if (o instanceof MetadataRetrieve) { 
    4667         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    4668         Integer result = retrieve.getPlaneTheC(imageIndex, planeIndex); 
    4669         if (result != null) return result; 
    4670       } 
    4671     } 
    4672     return null; 
    4673   } 
    4674  
    4675   /* @see MetadataRetrieve#getPlaneTheT(int, int) */ 
    4676   public Integer getPlaneTheT(int imageIndex, int planeIndex) { 
    4677     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    4678       Object o = iter.next(); 
    4679       if (o instanceof MetadataRetrieve) { 
    4680         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    4681         Integer result = retrieve.getPlaneTheT(imageIndex, planeIndex); 
    4682         if (result != null) return result; 
    4683       } 
    4684     } 
    4685     return null; 
    4686   } 
    4687  
    4688   /* @see MetadataRetrieve#getPlaneTheZ(int, int) */ 
    4689   public Integer getPlaneTheZ(int imageIndex, int planeIndex) { 
    4690     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    4691       Object o = iter.next(); 
    4692       if (o instanceof MetadataRetrieve) { 
    4693         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    4694         Integer result = retrieve.getPlaneTheZ(imageIndex, planeIndex); 
    4695         if (result != null) return result; 
    4696       } 
    4697     } 
    4698     return null; 
    4699   } 
    4700  
    4701   // - PlaneAnnotationRef property retrieval - 
    4702  
    4703   // - Plate property retrieval - 
    4704  
    4705   /* @see MetadataRetrieve#getPlateAnnotationRef(int, int) */ 
    4706   public String getPlateAnnotationRef(int plateIndex, int annotationRefIndex) { 
    4707     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    4708       Object o = iter.next(); 
    4709       if (o instanceof MetadataRetrieve) { 
    4710         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    4711         String result = retrieve.getPlateAnnotationRef(plateIndex, annotationRefIndex); 
    4712         if (result != null) return result; 
    4713       } 
    4714     } 
    4715     return null; 
    4716   } 
    4717  
    4718   /* @see MetadataRetrieve#getPlateColumnNamingConvention(int) */ 
    4719   public NamingConvention getPlateColumnNamingConvention(int plateIndex) { 
    4720     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    4721       Object o = iter.next(); 
    4722       if (o instanceof MetadataRetrieve) { 
    4723         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    4724         NamingConvention result = retrieve.getPlateColumnNamingConvention(plateIndex); 
    4725         if (result != null) return result; 
    4726       } 
    4727     } 
    4728     return null; 
    4729   } 
    4730  
    4731   /* @see MetadataRetrieve#getPlateColumns(int) */ 
    4732   public Integer getPlateColumns(int plateIndex) { 
    4733     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    4734       Object o = iter.next(); 
    4735       if (o instanceof MetadataRetrieve) { 
    4736         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    4737         Integer result = retrieve.getPlateColumns(plateIndex); 
    4738         if (result != null) return result; 
    4739       } 
    4740     } 
    4741     return null; 
    4742   } 
    4743  
    4744   /* @see MetadataRetrieve#getPlateDescription(int) */ 
    4745   public String getPlateDescription(int plateIndex) { 
    4746     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    4747       Object o = iter.next(); 
    4748       if (o instanceof MetadataRetrieve) { 
    4749         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    4750         String result = retrieve.getPlateDescription(plateIndex); 
    4751         if (result != null) return result; 
    4752       } 
    4753     } 
    4754     return null; 
    4755   } 
    4756  
    4757   /* @see MetadataRetrieve#getPlateExternalIdentifier(int) */ 
    4758   public String getPlateExternalIdentifier(int plateIndex) { 
    4759     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    4760       Object o = iter.next(); 
    4761       if (o instanceof MetadataRetrieve) { 
    4762         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    4763         String result = retrieve.getPlateExternalIdentifier(plateIndex); 
    4764         if (result != null) return result; 
    4765       } 
    4766     } 
    4767     return null; 
    4768   } 
    4769  
    4770   /* @see MetadataRetrieve#getPlateID(int) */ 
    4771   public String getPlateID(int plateIndex) { 
    4772     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    4773       Object o = iter.next(); 
    4774       if (o instanceof MetadataRetrieve) { 
    4775         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    4776         String result = retrieve.getPlateID(plateIndex); 
    4777         if (result != null) return result; 
    4778       } 
    4779     } 
    4780     return null; 
    4781   } 
    4782  
    4783   /* @see MetadataRetrieve#getPlateName(int) */ 
    4784   public String getPlateName(int plateIndex) { 
    4785     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    4786       Object o = iter.next(); 
    4787       if (o instanceof MetadataRetrieve) { 
    4788         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    4789         String result = retrieve.getPlateName(plateIndex); 
    4790         if (result != null) return result; 
    4791       } 
    4792     } 
    4793     return null; 
    4794   } 
    4795  
    4796   /* @see MetadataRetrieve#getPlateRowNamingConvention(int) */ 
    4797   public NamingConvention getPlateRowNamingConvention(int plateIndex) { 
    4798     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    4799       Object o = iter.next(); 
    4800       if (o instanceof MetadataRetrieve) { 
    4801         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    4802         NamingConvention result = retrieve.getPlateRowNamingConvention(plateIndex); 
    4803         if (result != null) return result; 
    4804       } 
    4805     } 
    4806     return null; 
    4807   } 
    4808  
    4809   /* @see MetadataRetrieve#getPlateRows(int) */ 
    4810   public Integer getPlateRows(int plateIndex) { 
    4811     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    4812       Object o = iter.next(); 
    4813       if (o instanceof MetadataRetrieve) { 
    4814         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    4815         Integer result = retrieve.getPlateRows(plateIndex); 
    4816         if (result != null) return result; 
    4817       } 
    4818     } 
    4819     return null; 
    4820   } 
    4821  
    4822   /* @see MetadataRetrieve#getPlateScreenRef(int, int) */ 
    4823   public String getPlateScreenRef(int plateIndex, int screenRefIndex) { 
    4824     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    4825       Object o = iter.next(); 
    4826       if (o instanceof MetadataRetrieve) { 
    4827         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    4828         String result = retrieve.getPlateScreenRef(plateIndex, screenRefIndex); 
    4829         if (result != null) return result; 
    4830       } 
    4831     } 
    4832     return null; 
    4833   } 
    4834  
    4835   /* @see MetadataRetrieve#getPlateStatus(int) */ 
    4836   public String getPlateStatus(int plateIndex) { 
    4837     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    4838       Object o = iter.next(); 
    4839       if (o instanceof MetadataRetrieve) { 
    4840         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    4841         String result = retrieve.getPlateStatus(plateIndex); 
    4842         if (result != null) return result; 
    4843       } 
    4844     } 
    4845     return null; 
    4846   } 
    4847  
    4848   /* @see MetadataRetrieve#getPlateWellOriginX(int) */ 
    4849   public Double getPlateWellOriginX(int plateIndex) { 
    4850     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    4851       Object o = iter.next(); 
    4852       if (o instanceof MetadataRetrieve) { 
    4853         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    4854         Double result = retrieve.getPlateWellOriginX(plateIndex); 
    4855         if (result != null) return result; 
    4856       } 
    4857     } 
    4858     return null; 
    4859   } 
    4860  
    4861   /* @see MetadataRetrieve#getPlateWellOriginY(int) */ 
    4862   public Double getPlateWellOriginY(int plateIndex) { 
    4863     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    4864       Object o = iter.next(); 
    4865       if (o instanceof MetadataRetrieve) { 
    4866         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    4867         Double result = retrieve.getPlateWellOriginY(plateIndex); 
    4868         if (result != null) return result; 
    4869       } 
    4870     } 
    4871     return null; 
    4872   } 
    4873  
    4874   // - PlateAcquisition property retrieval - 
    4875  
    4876   /* @see MetadataRetrieve#getPlateAcquisitionAnnotationRef(int, int, int) */ 
    4877   public String getPlateAcquisitionAnnotationRef(int plateIndex, int plateAcquisitionIndex, int annotationRefIndex) { 
    4878     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    4879       Object o = iter.next(); 
    4880       if (o instanceof MetadataRetrieve) { 
    4881         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    4882         String result = retrieve.getPlateAcquisitionAnnotationRef(plateIndex, plateAcquisitionIndex, annotationRefIndex); 
    4883         if (result != null) return result; 
    4884       } 
    4885     } 
    4886     return null; 
    4887   } 
    4888  
    4889   /* @see MetadataRetrieve#getPlateAcquisitionDescription(int, int) */ 
    4890   public String getPlateAcquisitionDescription(int plateIndex, int plateAcquisitionIndex) { 
    4891     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    4892       Object o = iter.next(); 
    4893       if (o instanceof MetadataRetrieve) { 
    4894         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    4895         String result = retrieve.getPlateAcquisitionDescription(plateIndex, plateAcquisitionIndex); 
    4896         if (result != null) return result; 
    4897       } 
    4898     } 
    4899     return null; 
    4900   } 
    4901  
    4902   /* @see MetadataRetrieve#getPlateAcquisitionEndTime(int, int) */ 
    4903   public String getPlateAcquisitionEndTime(int plateIndex, int plateAcquisitionIndex) { 
    4904     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    4905       Object o = iter.next(); 
    4906       if (o instanceof MetadataRetrieve) { 
    4907         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    4908         String result = retrieve.getPlateAcquisitionEndTime(plateIndex, plateAcquisitionIndex); 
    4909         if (result != null) return result; 
    4910       } 
    4911     } 
    4912     return null; 
    4913   } 
    4914  
    4915   /* @see MetadataRetrieve#getPlateAcquisitionID(int, int) */ 
    4916   public String getPlateAcquisitionID(int plateIndex, int plateAcquisitionIndex) { 
    4917     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    4918       Object o = iter.next(); 
    4919       if (o instanceof MetadataRetrieve) { 
    4920         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    4921         String result = retrieve.getPlateAcquisitionID(plateIndex, plateAcquisitionIndex); 
    4922         if (result != null) return result; 
    4923       } 
    4924     } 
    4925     return null; 
    4926   } 
    4927  
    4928   /* @see MetadataRetrieve#getPlateAcquisitionMaximumFieldCount(int, int) */ 
    4929   public Integer getPlateAcquisitionMaximumFieldCount(int plateIndex, int plateAcquisitionIndex) { 
    4930     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    4931       Object o = iter.next(); 
    4932       if (o instanceof MetadataRetrieve) { 
    4933         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    4934         Integer result = retrieve.getPlateAcquisitionMaximumFieldCount(plateIndex, plateAcquisitionIndex); 
    4935         if (result != null) return result; 
    4936       } 
    4937     } 
    4938     return null; 
    4939   } 
    4940  
    4941   /* @see MetadataRetrieve#getPlateAcquisitionName(int, int) */ 
    4942   public String getPlateAcquisitionName(int plateIndex, int plateAcquisitionIndex) { 
    4943     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    4944       Object o = iter.next(); 
    4945       if (o instanceof MetadataRetrieve) { 
    4946         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    4947         String result = retrieve.getPlateAcquisitionName(plateIndex, plateAcquisitionIndex); 
    4948         if (result != null) return result; 
    4949       } 
    4950     } 
    4951     return null; 
    4952   } 
    4953  
    4954   /* @see MetadataRetrieve#getPlateAcquisitionStartTime(int, int) */ 
    4955   public String getPlateAcquisitionStartTime(int plateIndex, int plateAcquisitionIndex) { 
    4956     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    4957       Object o = iter.next(); 
    4958       if (o instanceof MetadataRetrieve) { 
    4959         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    4960         String result = retrieve.getPlateAcquisitionStartTime(plateIndex, plateAcquisitionIndex); 
    4961         if (result != null) return result; 
    4962       } 
    4963     } 
    4964     return null; 
    4965   } 
    4966  
    4967   /* @see MetadataRetrieve#getPlateAcquisitionWellSampleRef(int, int, int) */ 
    4968   public String getPlateAcquisitionWellSampleRef(int plateIndex, int plateAcquisitionIndex, int wellSampleRefIndex) { 
    4969     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    4970       Object o = iter.next(); 
    4971       if (o instanceof MetadataRetrieve) { 
    4972         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    4973         String result = retrieve.getPlateAcquisitionWellSampleRef(plateIndex, plateAcquisitionIndex, wellSampleRefIndex); 
    4974         if (result != null) return result; 
    4975       } 
    4976     } 
    4977     return null; 
    4978   } 
    4979  
    4980   // - PlateAcquisitionAnnotationRef property retrieval - 
    4981  
    4982   // - PlateAnnotationRef property retrieval - 
    4983  
    4984   // - PlateRef property retrieval - 
    4985  
    4986   // - Point property retrieval - 
    4987  
    4988   /* @see MetadataRetrieve#getPointDescription(int, int) */ 
    4989   public String getPointDescription(int roiIndex, int shapeIndex) { 
    4990     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    4991       Object o = iter.next(); 
    4992       if (o instanceof MetadataRetrieve) { 
    4993         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    4994         String result = retrieve.getPointDescription(roiIndex, shapeIndex); 
    4995         if (result != null) return result; 
    4996       } 
    4997     } 
    4998     return null; 
    4999   } 
    5000  
    5001   /* @see MetadataRetrieve#getPointFill(int, int) */ 
    5002   public Integer getPointFill(int roiIndex, int shapeIndex) { 
    5003     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    5004       Object o = iter.next(); 
    5005       if (o instanceof MetadataRetrieve) { 
    5006         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    5007         Integer result = retrieve.getPointFill(roiIndex, shapeIndex); 
    5008         if (result != null) return result; 
    5009       } 
    5010     } 
    5011     return null; 
    5012   } 
    5013  
    5014   /* @see MetadataRetrieve#getPointFontSize(int, int) */ 
    5015   public Integer getPointFontSize(int roiIndex, int shapeIndex) { 
    5016     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    5017       Object o = iter.next(); 
    5018       if (o instanceof MetadataRetrieve) { 
    5019         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    5020         Integer result = retrieve.getPointFontSize(roiIndex, shapeIndex); 
    5021         if (result != null) return result; 
    5022       } 
    5023     } 
    5024     return null; 
    5025   } 
    5026  
    5027   /* @see MetadataRetrieve#getPointID(int, int) */ 
    5028   public String getPointID(int roiIndex, int shapeIndex) { 
    5029     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    5030       Object o = iter.next(); 
    5031       if (o instanceof MetadataRetrieve) { 
    5032         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    5033         String result = retrieve.getPointID(roiIndex, shapeIndex); 
    5034         if (result != null) return result; 
    5035       } 
    5036     } 
    5037     return null; 
    5038   } 
    5039  
    5040   /* @see MetadataRetrieve#getPointLabel(int, int) */ 
    5041   public String getPointLabel(int roiIndex, int shapeIndex) { 
    5042     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    5043       Object o = iter.next(); 
    5044       if (o instanceof MetadataRetrieve) { 
    5045         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    5046         String result = retrieve.getPointLabel(roiIndex, shapeIndex); 
    5047         if (result != null) return result; 
    5048       } 
    5049     } 
    5050     return null; 
    5051   } 
    5052  
    5053   /* @see MetadataRetrieve#getPointName(int, int) */ 
    5054   public String getPointName(int roiIndex, int shapeIndex) { 
    5055     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    5056       Object o = iter.next(); 
    5057       if (o instanceof MetadataRetrieve) { 
    5058         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    5059         String result = retrieve.getPointName(roiIndex, shapeIndex); 
    5060         if (result != null) return result; 
    5061       } 
    5062     } 
    5063     return null; 
    5064   } 
    5065  
    5066   /* @see MetadataRetrieve#getPointStroke(int, int) */ 
    5067   public Integer getPointStroke(int roiIndex, int shapeIndex) { 
    5068     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    5069       Object o = iter.next(); 
    5070       if (o instanceof MetadataRetrieve) { 
    5071         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    5072         Integer result = retrieve.getPointStroke(roiIndex, shapeIndex); 
    5073         if (result != null) return result; 
    5074       } 
    5075     } 
    5076     return null; 
    5077   } 
    5078  
    5079   /* @see MetadataRetrieve#getPointStrokeDashArray(int, int) */ 
    5080   public String getPointStrokeDashArray(int roiIndex, int shapeIndex) { 
    5081     for (Iterator iter = delegates.iterator(); iter.hasNext();) { 
    5082       Object o = iter.next(); 
    5083       if (o instanceof MetadataRetrieve) { 
    5084         MetadataRetrieve retrieve = (MetadataRetrieve) o; 
    5085         String result = retrieve.getPointStrokeDashArray(roiIndex, shapeIndex); 
    5086         if (result != null) return result; 
    5087