// src directory =/home/dke/Documents/project/nexus//src/au/gov/ansto/bragg/nexus/auto/
package au.gov.ansto.bragg.nexus.auto;
import neutron.nexus.*;
import au.gov.ansto.bragg.nexus.base.*;

//  Generated from XML template(http://svn.nexusformat.org/definitions/trunk/base_classes/NXinstrument.xml)
/** 
URL:     http://www.nexus.anl.gov/classes/xml/NXinstrument.xml
Editor:  NIAC
$Id$

Template of instrument descriptions comprising various beamline 
components. Each component will also be a NeXus group defined by its 
distance from the sample. Negative distances represent beamline 
components that are before the sample while positive distances 
represent components that are after the sample. This device allows 
the unique identification of beamline components in a way that is 
valid for both reactor and pulsed instrumentation.

 */

 public class NXinstrument
 extends NXgroup_ {


/** Property string for bean property 'extraName' */
final static public String $extraName = "extraName";

// indexed = false
// required = false
// Extracted NeXus multiplicity indicator (?) means (May occur 0 or one times (i.e. no more than once))
/** {Name of instrument}? */
private ExtraName extraName_;
// Extracted NeXus multiplicity indicator (?) means (May occur 0 or one times (i.e. no more than once))
/** {Name of instrument}? */
public ExtraName getExtraName(){
 return extraName_;
}
public void setExtraName(final ExtraName extraName){
 extraName_ = extraName;
}

/** Property string for bean property 'nXsource' */
final static public String $nXsource = "nXsource";

// indexed = true
// required = false
// Extracted NeXus multiplicity indicator (*) means (May occur 0 or more times)
/** * */
private java.util.List<NXsource> nXsource_;
private java.util.List<NXsource> nXsource(){
 if (nXsource_ == null) nXsource_ = new java.util.ArrayList<NXsource>();
 return nXsource_;
}
// Extracted NeXus multiplicity indicator (*) means (May occur 0 or more times)
/** * */
public NXsource[] getNXsource(){
 return nXsource().toArray(new NXsource[0]);
}
public NXsource getNXsource(int index){
 return nXsource().get(index);
}
public void addNXsource(final NXsource nXsource){
 nXsource().add(nXsource);
}

/** Property string for bean property 'nXdisk_chopper' */
final static public String $nXdisk_chopper = "nXdisk_chopper";

// indexed = true
// required = false
// Extracted NeXus multiplicity indicator (*) means (May occur 0 or more times)
/** * */
private java.util.List<NXdisk_chopper> nXdisk_chopper_;
private java.util.List<NXdisk_chopper> nXdisk_chopper(){
 if (nXdisk_chopper_ == null) nXdisk_chopper_ = new java.util.ArrayList<NXdisk_chopper>();
 return nXdisk_chopper_;
}
// Extracted NeXus multiplicity indicator (*) means (May occur 0 or more times)
/** * */
public NXdisk_chopper[] getNXdisk_chopper(){
 return nXdisk_chopper().toArray(new NXdisk_chopper[0]);
}
public NXdisk_chopper getNXdisk_chopper(int index){
 return nXdisk_chopper().get(index);
}
public void addNXdisk_chopper(final NXdisk_chopper nXdisk_chopper){
 nXdisk_chopper().add(nXdisk_chopper);
}

/** Property string for bean property 'nXfermi_chopper' */
final static public String $nXfermi_chopper = "nXfermi_chopper";

// indexed = true
// required = false
// Extracted NeXus multiplicity indicator (*) means (May occur 0 or more times)
/** * */
private java.util.List<NXfermi_chopper> nXfermi_chopper_;
private java.util.List<NXfermi_chopper> nXfermi_chopper(){
 if (nXfermi_chopper_ == null) nXfermi_chopper_ = new java.util.ArrayList<NXfermi_chopper>();
 return nXfermi_chopper_;
}
// Extracted NeXus multiplicity indicator (*) means (May occur 0 or more times)
/** * */
public NXfermi_chopper[] getNXfermi_chopper(){
 return nXfermi_chopper().toArray(new NXfermi_chopper[0]);
}
public NXfermi_chopper getNXfermi_chopper(int index){
 return nXfermi_chopper().get(index);
}
public void addNXfermi_chopper(final NXfermi_chopper nXfermi_chopper){
 nXfermi_chopper().add(nXfermi_chopper);
}

/** Property string for bean property 'nXvelocity_selector' */
final static public String $nXvelocity_selector = "nXvelocity_selector";

// indexed = true
// required = false
// Extracted NeXus multiplicity indicator (*) means (May occur 0 or more times)
/** * */
private java.util.List<NXvelocity_selector> nXvelocity_selector_;
private java.util.List<NXvelocity_selector> nXvelocity_selector(){
 if (nXvelocity_selector_ == null) nXvelocity_selector_ = new java.util.ArrayList<NXvelocity_selector>();
 return nXvelocity_selector_;
}
// Extracted NeXus multiplicity indicator (*) means (May occur 0 or more times)
/** * */
public NXvelocity_selector[] getNXvelocity_selector(){
 return nXvelocity_selector().toArray(new NXvelocity_selector[0]);
}
public NXvelocity_selector getNXvelocity_selector(int index){
 return nXvelocity_selector().get(index);
}
public void addNXvelocity_selector(final NXvelocity_selector nXvelocity_selector){
 nXvelocity_selector().add(nXvelocity_selector);
}

/** Property string for bean property 'nXguide' */
final static public String $nXguide = "nXguide";

// indexed = true
// required = false
// Extracted NeXus multiplicity indicator (*) means (May occur 0 or more times)
/** * */
private java.util.List<NXguide> nXguide_;
private java.util.List<NXguide> nXguide(){
 if (nXguide_ == null) nXguide_ = new java.util.ArrayList<NXguide>();
 return nXguide_;
}
// Extracted NeXus multiplicity indicator (*) means (May occur 0 or more times)
/** * */
public NXguide[] getNXguide(){
 return nXguide().toArray(new NXguide[0]);
}
public NXguide getNXguide(int index){
 return nXguide().get(index);
}
public void addNXguide(final NXguide nXguide){
 nXguide().add(nXguide);
}

/** Property string for bean property 'nXcrystal' */
final static public String $nXcrystal = "nXcrystal";

// indexed = true
// required = false
// Extracted NeXus multiplicity indicator (*) means (May occur 0 or more times)
/** * */
private java.util.List<NXcrystal> nXcrystal_;
private java.util.List<NXcrystal> nXcrystal(){
 if (nXcrystal_ == null) nXcrystal_ = new java.util.ArrayList<NXcrystal>();
 return nXcrystal_;
}
// Extracted NeXus multiplicity indicator (*) means (May occur 0 or more times)
/** * */
public NXcrystal[] getNXcrystal(){
 return nXcrystal().toArray(new NXcrystal[0]);
}
public NXcrystal getNXcrystal(int index){
 return nXcrystal().get(index);
}
public void addNXcrystal(final NXcrystal nXcrystal){
 nXcrystal().add(nXcrystal);
}

/** Property string for bean property 'nXaperture' */
final static public String $nXaperture = "nXaperture";

// indexed = true
// required = false
// Extracted NeXus multiplicity indicator (*) means (May occur 0 or more times)
/** * */
private java.util.List<NXaperture> nXaperture_;
private java.util.List<NXaperture> nXaperture(){
 if (nXaperture_ == null) nXaperture_ = new java.util.ArrayList<NXaperture>();
 return nXaperture_;
}
// Extracted NeXus multiplicity indicator (*) means (May occur 0 or more times)
/** * */
public NXaperture[] getNXaperture(){
 return nXaperture().toArray(new NXaperture[0]);
}
public NXaperture getNXaperture(int index){
 return nXaperture().get(index);
}
public void addNXaperture(final NXaperture nXaperture){
 nXaperture().add(nXaperture);
}

/** Property string for bean property 'nXfilter' */
final static public String $nXfilter = "nXfilter";

// indexed = true
// required = false
// Extracted NeXus multiplicity indicator (*) means (May occur 0 or more times)
/** * */
private java.util.List<NXfilter> nXfilter_;
private java.util.List<NXfilter> nXfilter(){
 if (nXfilter_ == null) nXfilter_ = new java.util.ArrayList<NXfilter>();
 return nXfilter_;
}
// Extracted NeXus multiplicity indicator (*) means (May occur 0 or more times)
/** * */
public NXfilter[] getNXfilter(){
 return nXfilter().toArray(new NXfilter[0]);
}
public NXfilter getNXfilter(int index){
 return nXfilter().get(index);
}
public void addNXfilter(final NXfilter nXfilter){
 nXfilter().add(nXfilter);
}

/** Property string for bean property 'nXcollimator' */
final static public String $nXcollimator = "nXcollimator";

// indexed = true
// required = false
// Extracted NeXus multiplicity indicator (*) means (May occur 0 or more times)
/** * */
private java.util.List<NXcollimator> nXcollimator_;
private java.util.List<NXcollimator> nXcollimator(){
 if (nXcollimator_ == null) nXcollimator_ = new java.util.ArrayList<NXcollimator>();
 return nXcollimator_;
}
// Extracted NeXus multiplicity indicator (*) means (May occur 0 or more times)
/** * */
public NXcollimator[] getNXcollimator(){
 return nXcollimator().toArray(new NXcollimator[0]);
}
public NXcollimator getNXcollimator(int index){
 return nXcollimator().get(index);
}
public void addNXcollimator(final NXcollimator nXcollimator){
 nXcollimator().add(nXcollimator);
}

/** Property string for bean property 'nXattenuator' */
final static public String $nXattenuator = "nXattenuator";

// indexed = true
// required = false
// Extracted NeXus multiplicity indicator (*) means (May occur 0 or more times)
/** * */
private java.util.List<NXattenuator> nXattenuator_;
private java.util.List<NXattenuator> nXattenuator(){
 if (nXattenuator_ == null) nXattenuator_ = new java.util.ArrayList<NXattenuator>();
 return nXattenuator_;
}
// Extracted NeXus multiplicity indicator (*) means (May occur 0 or more times)
/** * */
public NXattenuator[] getNXattenuator(){
 return nXattenuator().toArray(new NXattenuator[0]);
}
public NXattenuator getNXattenuator(int index){
 return nXattenuator().get(index);
}
public void addNXattenuator(final NXattenuator nXattenuator){
 nXattenuator().add(nXattenuator);
}

/** Property string for bean property 'nXpolarizer' */
final static public String $nXpolarizer = "nXpolarizer";

// indexed = true
// required = false
// Extracted NeXus multiplicity indicator (*) means (May occur 0 or more times)
/** * */
private java.util.List<NXpolarizer> nXpolarizer_;
private java.util.List<NXpolarizer> nXpolarizer(){
 if (nXpolarizer_ == null) nXpolarizer_ = new java.util.ArrayList<NXpolarizer>();
 return nXpolarizer_;
}
// Extracted NeXus multiplicity indicator (*) means (May occur 0 or more times)
/** * */
public NXpolarizer[] getNXpolarizer(){
 return nXpolarizer().toArray(new NXpolarizer[0]);
}
public NXpolarizer getNXpolarizer(int index){
 return nXpolarizer().get(index);
}
public void addNXpolarizer(final NXpolarizer nXpolarizer){
 nXpolarizer().add(nXpolarizer);
}

/** Property string for bean property 'nXflipper' */
final static public String $nXflipper = "nXflipper";

// indexed = true
// required = false
// Extracted NeXus multiplicity indicator (*) means (May occur 0 or more times)
/** * */
private java.util.List<NXflipper> nXflipper_;
private java.util.List<NXflipper> nXflipper(){
 if (nXflipper_ == null) nXflipper_ = new java.util.ArrayList<NXflipper>();
 return nXflipper_;
}
// Extracted NeXus multiplicity indicator (*) means (May occur 0 or more times)
/** * */
public NXflipper[] getNXflipper(){
 return nXflipper().toArray(new NXflipper[0]);
}
public NXflipper getNXflipper(int index){
 return nXflipper().get(index);
}
public void addNXflipper(final NXflipper nXflipper){
 nXflipper().add(nXflipper);
}

/** Property string for bean property 'nXmirror' */
final static public String $nXmirror = "nXmirror";

// indexed = true
// required = false
// Extracted NeXus multiplicity indicator (*) means (May occur 0 or more times)
/** * */
private java.util.List<NXmirror> nXmirror_;
private java.util.List<NXmirror> nXmirror(){
 if (nXmirror_ == null) nXmirror_ = new java.util.ArrayList<NXmirror>();
 return nXmirror_;
}
// Extracted NeXus multiplicity indicator (*) means (May occur 0 or more times)
/** * */
public NXmirror[] getNXmirror(){
 return nXmirror().toArray(new NXmirror[0]);
}
public NXmirror getNXmirror(int index){
 return nXmirror().get(index);
}
public void addNXmirror(final NXmirror nXmirror){
 nXmirror().add(nXmirror);
}

/** Property string for bean property 'nXdetector' */
final static public String $nXdetector = "nXdetector";

// indexed = true
// required = false
// Extracted NeXus multiplicity indicator (*) means (May occur 0 or more times)
/** * */
private java.util.List<NXdetector> nXdetector_;
private java.util.List<NXdetector> nXdetector(){
 if (nXdetector_ == null) nXdetector_ = new java.util.ArrayList<NXdetector>();
 return nXdetector_;
}
// Extracted NeXus multiplicity indicator (*) means (May occur 0 or more times)
/** * */
public NXdetector[] getNXdetector(){
 return nXdetector().toArray(new NXdetector[0]);
}
public NXdetector getNXdetector(int index){
 return nXdetector().get(index);
}
public void addNXdetector(final NXdetector nXdetector){
 nXdetector().add(nXdetector);
}

/** Property string for bean property 'nXbeam_stop' */
final static public String $nXbeam_stop = "nXbeam_stop";

// indexed = true
// required = false
// Extracted NeXus multiplicity indicator (*) means (May occur 0 or more times)
/** * */
private java.util.List<NXbeam_stop> nXbeam_stop_;
private java.util.List<NXbeam_stop> nXbeam_stop(){
 if (nXbeam_stop_ == null) nXbeam_stop_ = new java.util.ArrayList<NXbeam_stop>();
 return nXbeam_stop_;
}
// Extracted NeXus multiplicity indicator (*) means (May occur 0 or more times)
/** * */
public NXbeam_stop[] getNXbeam_stop(){
 return nXbeam_stop().toArray(new NXbeam_stop[0]);
}
public NXbeam_stop getNXbeam_stop(int index){
 return nXbeam_stop().get(index);
}
public void addNXbeam_stop(final NXbeam_stop nXbeam_stop){
 nXbeam_stop().add(nXbeam_stop);
}


/** constructor */
public NXinstrument(){
 super();
}



static public class ExtraName
 extends NXdataItem_ {


/** Property string for bean property 'short_name' */
final static public String $short_name = "short_name";

// indexed = false
// required = false
private String short_name_;
public String getShort_name(){
 return short_name_;
}
public void setShort_name(final String short_name){
 short_name_ = short_name;
}


/** constructor */
public ExtraName(){
 super();
}


/** constructor */
public ExtraName(Object content){
 super(content);
}

}
}
