0001: //
0002: // This file was generated by the JavaTM Architecture for XML Binding(JAXB) Reference Implementation, vJAXB 2.0 in JDK 1.6
0003: // See <a href="http://java.sun.com/xml/jaxb">http://java.sun.com/xml/jaxb</a>
0004: // Any modifications to this file will be lost upon recompilation of the source schema.
0005: // Generated on: 2007.03.17 at 08:38:02 AM PDT
0006: //
0007:
0008: package org.collada.colladaschema;
0009:
0010: import java.util.ArrayList;
0011: import java.util.List;
0012: import javax.xml.bind.annotation.XmlAccessType;
0013: import javax.xml.bind.annotation.XmlAccessorType;
0014: import javax.xml.bind.annotation.XmlAttribute;
0015: import javax.xml.bind.annotation.XmlElement;
0016: import javax.xml.bind.annotation.XmlList;
0017: import javax.xml.bind.annotation.XmlType;
0018: import javax.xml.bind.annotation.adapters.CollapsedStringAdapter;
0019: import javax.xml.bind.annotation.adapters.XmlJavaTypeAdapter;
0020:
0021: /**
0022: *
0023: * Assigns a new value to a previously defined parameter.
0024: *
0025: *
0026: * <p>Java class for cg_setparam complex type.
0027: *
0028: * <p>The following schema fragment specifies the expected content contained within this class.
0029: *
0030: * <pre>
0031: * <complexType name="cg_setparam">
0032: * <complexContent>
0033: * <restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
0034: * <choice>
0035: * <group ref="{http://www.collada.org/2005/11/COLLADASchema}cg_param_type"/>
0036: * <element name="usertype" type="{http://www.collada.org/2005/11/COLLADASchema}cg_setuser_type"/>
0037: * <element name="array" type="{http://www.collada.org/2005/11/COLLADASchema}cg_setarray_type"/>
0038: * <element name="connect_param" type="{http://www.collada.org/2005/11/COLLADASchema}cg_connect_param"/>
0039: * </choice>
0040: * <attribute name="program" type="{http://www.w3.org/2001/XMLSchema}NCName" />
0041: * <attribute name="ref" use="required" type="{http://www.collada.org/2005/11/COLLADASchema}cg_identifier" />
0042: * </restriction>
0043: * </complexContent>
0044: * </complexType>
0045: * </pre>
0046: *
0047: *
0048: */
0049: @XmlAccessorType(XmlAccessType.FIELD)
0050: @XmlType(name="cg_setparam",propOrder={"int4X3","half3X3","fixed1X1","bool2X1","bool2X3","fixed1X3","half2","surface","float1","half1","fixed2","fixed4X3","bool2","samplerRECT","half1X4","bool2X4","usertype","fixed4X1","fixed1","bool4","int2X2","int1X1","sampler1D","half4","bool4X2","int3","float4X2","float2X3","bool1X3","half2X1","samplerDEPTH","int3X4","int3X1","fixed2X4","sampler3D","half1X2","int4","bool3X3","bool1X4","bool2X2","float1X4","float3X4","fixed2X2","int4X2","bool1","float1X1","half2X3","connectParam","int3X3","_enum","fixed3","float1X2","float3X1","samplerCUBE","bool3X1","bool","int2X4","float2","bool3X4","half4X3","float1X3","float4","float2X2","fixed4","fixed3X1","int2X3","fixed3X2","fixed2X3","int2X1","int1X4","fixed4X2","int1X3","int1","half3","float4X1","_int","half2X4","half1X1","half3X2","bool3","bool1X1","float3X2","int1X2","string","bool1X2","fixed1X4","half4X1","float2X4","int4X4","half1X3","fixed3X3","float4X4","fixed2X1","fixed","bool4X1","float4X3","int4X1","float3X3","bool4X4","fixed3X4","half2X2","half4X4","half3X1","int3X2","int2","float2X1","half4X2","half3X4","half","fixed4X4","bool3X2","float3","bool4X3","array","fixed1X2","sampler2D","_float"})
0051: public class CgSetparam {
0052:
0053: @XmlList
0054: @XmlElement(name="int4x3",type=Integer.class)
0055: protected List<Integer> int4X3;
0056: @XmlList
0057: @XmlElement(name="half3x3",type=Float.class)
0058: protected List<Float> half3X3;
0059: @XmlList
0060: @XmlElement(name="fixed1x1",type=Float.class)
0061: protected List<Float> fixed1X1;
0062: @XmlList
0063: @XmlElement(name="bool2x1",type=Boolean.class)
0064: protected List<Boolean> bool2X1;
0065: @XmlList
0066: @XmlElement(name="bool2x3",type=Boolean.class)
0067: protected List<Boolean> bool2X3;
0068: @XmlList
0069: @XmlElement(name="fixed1x3",type=Float.class)
0070: protected List<Float> fixed1X3;
0071: @XmlList
0072: @XmlElement(type=Float.class)
0073: protected List<Float> half2;
0074: protected CgSurfaceType surface;
0075: protected Float float1;
0076: protected Float half1;
0077: @XmlList
0078: @XmlElement(type=Float.class)
0079: protected List<Float> fixed2;
0080: @XmlList
0081: @XmlElement(name="fixed4x3",type=Float.class)
0082: protected List<Float> fixed4X3;
0083: @XmlList
0084: @XmlElement(type=Boolean.class)
0085: protected List<Boolean> bool2;
0086: protected CgSamplerRECT samplerRECT;
0087: @XmlList
0088: @XmlElement(name="half1x4",type=Float.class)
0089: protected List<Float> half1X4;
0090: @XmlList
0091: @XmlElement(name="bool2x4",type=Boolean.class)
0092: protected List<Boolean> bool2X4;
0093: protected CgSetuserType usertype;
0094: @XmlList
0095: @XmlElement(name="fixed4x1",type=Float.class)
0096: protected List<Float> fixed4X1;
0097: protected Float fixed1;
0098: @XmlList
0099: @XmlElement(type=Boolean.class)
0100: protected List<Boolean> bool4;
0101: @XmlList
0102: @XmlElement(name="int2x2",type=Integer.class)
0103: protected List<Integer> int2X2;
0104: @XmlList
0105: @XmlElement(name="int1x1",type=Integer.class)
0106: protected List<Integer> int1X1;
0107: protected CgSampler1D sampler1D;
0108: @XmlList
0109: @XmlElement(type=Float.class)
0110: protected List<Float> half4;
0111: @XmlList
0112: @XmlElement(name="bool4x2",type=Boolean.class)
0113: protected List<Boolean> bool4X2;
0114: @XmlList
0115: @XmlElement(type=Integer.class)
0116: protected List<Integer> int3;
0117: @XmlList
0118: @XmlElement(name="float4x2",type=Float.class)
0119: protected List<Float> float4X2;
0120: @XmlList
0121: @XmlElement(name="float2x3",type=Float.class)
0122: protected List<Float> float2X3;
0123: @XmlList
0124: @XmlElement(name="bool1x3",type=Boolean.class)
0125: protected List<Boolean> bool1X3;
0126: @XmlList
0127: @XmlElement(name="half2x1",type=Float.class)
0128: protected List<Float> half2X1;
0129: protected CgSamplerDEPTH samplerDEPTH;
0130: @XmlList
0131: @XmlElement(name="int3x4",type=Integer.class)
0132: protected List<Integer> int3X4;
0133: @XmlList
0134: @XmlElement(name="int3x1",type=Integer.class)
0135: protected List<Integer> int3X1;
0136: @XmlList
0137: @XmlElement(name="fixed2x4",type=Float.class)
0138: protected List<Float> fixed2X4;
0139: protected CgSampler3D sampler3D;
0140: @XmlList
0141: @XmlElement(name="half1x2",type=Float.class)
0142: protected List<Float> half1X2;
0143: @XmlList
0144: @XmlElement(type=Integer.class)
0145: protected List<Integer> int4;
0146: @XmlList
0147: @XmlElement(name="bool3x3",type=Boolean.class)
0148: protected List<Boolean> bool3X3;
0149: @XmlList
0150: @XmlElement(name="bool1x4",type=Boolean.class)
0151: protected List<Boolean> bool1X4;
0152: @XmlList
0153: @XmlElement(name="bool2x2",type=Boolean.class)
0154: protected List<Boolean> bool2X2;
0155: @XmlList
0156: @XmlElement(name="float1x4",type=Float.class)
0157: protected List<Float> float1X4;
0158: @XmlList
0159: @XmlElement(name="float3x4",type=Float.class)
0160: protected List<Float> float3X4;
0161: @XmlList
0162: @XmlElement(name="fixed2x2",type=Float.class)
0163: protected List<Float> fixed2X2;
0164: @XmlList
0165: @XmlElement(name="int4x2",type=Integer.class)
0166: protected List<Integer> int4X2;
0167: protected Boolean bool1;
0168: @XmlList
0169: @XmlElement(name="float1x1",type=Float.class)
0170: protected List<Float> float1X1;
0171: @XmlList
0172: @XmlElement(name="half2x3",type=Float.class)
0173: protected List<Float> half2X3;
0174: @XmlElement(name="connect_param")
0175: protected CgConnectParam connectParam;
0176: @XmlList
0177: @XmlElement(name="int3x3",type=Integer.class)
0178: protected List<Integer> int3X3;
0179: @XmlElement(name="enum")
0180: protected String _enum;
0181: @XmlList
0182: @XmlElement(type=Float.class)
0183: protected List<Float> fixed3;
0184: @XmlList
0185: @XmlElement(name="float1x2",type=Float.class)
0186: protected List<Float> float1X2;
0187: @XmlList
0188: @XmlElement(name="float3x1",type=Float.class)
0189: protected List<Float> float3X1;
0190: protected CgSamplerCUBE samplerCUBE;
0191: @XmlList
0192: @XmlElement(name="bool3x1",type=Boolean.class)
0193: protected List<Boolean> bool3X1;
0194: protected Boolean bool;
0195: @XmlList
0196: @XmlElement(name="int2x4",type=Integer.class)
0197: protected List<Integer> int2X4;
0198: @XmlList
0199: @XmlElement(type=Float.class)
0200: protected List<Float> float2;
0201: @XmlList
0202: @XmlElement(name="bool3x4",type=Boolean.class)
0203: protected List<Boolean> bool3X4;
0204: @XmlList
0205: @XmlElement(name="half4x3",type=Float.class)
0206: protected List<Float> half4X3;
0207: @XmlList
0208: @XmlElement(name="float1x3",type=Float.class)
0209: protected List<Float> float1X3;
0210: @XmlList
0211: @XmlElement(type=Float.class)
0212: protected List<Float> float4;
0213: @XmlList
0214: @XmlElement(name="float2x2",type=Float.class)
0215: protected List<Float> float2X2;
0216: @XmlList
0217: @XmlElement(type=Float.class)
0218: protected List<Float> fixed4;
0219: @XmlList
0220: @XmlElement(name="fixed3x1",type=Float.class)
0221: protected List<Float> fixed3X1;
0222: @XmlList
0223: @XmlElement(name="int2x3",type=Integer.class)
0224: protected List<Integer> int2X3;
0225: @XmlList
0226: @XmlElement(name="fixed3x2",type=Float.class)
0227: protected List<Float> fixed3X2;
0228: @XmlList
0229: @XmlElement(name="fixed2x3",type=Float.class)
0230: protected List<Float> fixed2X3;
0231: @XmlList
0232: @XmlElement(name="int2x1",type=Integer.class)
0233: protected List<Integer> int2X1;
0234: @XmlList
0235: @XmlElement(name="int1x4",type=Integer.class)
0236: protected List<Integer> int1X4;
0237: @XmlList
0238: @XmlElement(name="fixed4x2",type=Float.class)
0239: protected List<Float> fixed4X2;
0240: @XmlList
0241: @XmlElement(name="int1x3",type=Integer.class)
0242: protected List<Integer> int1X3;
0243: protected Integer int1;
0244: @XmlList
0245: @XmlElement(type=Float.class)
0246: protected List<Float> half3;
0247: @XmlList
0248: @XmlElement(name="float4x1",type=Float.class)
0249: protected List<Float> float4X1;
0250: @XmlElement(name="int")
0251: protected Integer _int;
0252: @XmlList
0253: @XmlElement(name="half2x4",type=Float.class)
0254: protected List<Float> half2X4;
0255: @XmlList
0256: @XmlElement(name="half1x1",type=Float.class)
0257: protected List<Float> half1X1;
0258: @XmlList
0259: @XmlElement(name="half3x2",type=Float.class)
0260: protected List<Float> half3X2;
0261: @XmlList
0262: @XmlElement(type=Boolean.class)
0263: protected List<Boolean> bool3;
0264: @XmlList
0265: @XmlElement(name="bool1x1",type=Boolean.class)
0266: protected List<Boolean> bool1X1;
0267: @XmlList
0268: @XmlElement(name="float3x2",type=Float.class)
0269: protected List<Float> float3X2;
0270: @XmlList
0271: @XmlElement(name="int1x2",type=Integer.class)
0272: protected List<Integer> int1X2;
0273: protected String string;
0274: @XmlList
0275: @XmlElement(name="bool1x2",type=Boolean.class)
0276: protected List<Boolean> bool1X2;
0277: @XmlList
0278: @XmlElement(name="fixed1x4",type=Float.class)
0279: protected List<Float> fixed1X4;
0280: @XmlList
0281: @XmlElement(name="half4x1",type=Float.class)
0282: protected List<Float> half4X1;
0283: @XmlList
0284: @XmlElement(name="float2x4",type=Float.class)
0285: protected List<Float> float2X4;
0286: @XmlList
0287: @XmlElement(name="int4x4",type=Integer.class)
0288: protected List<Integer> int4X4;
0289: @XmlList
0290: @XmlElement(name="half1x3",type=Float.class)
0291: protected List<Float> half1X3;
0292: @XmlList
0293: @XmlElement(name="fixed3x3",type=Float.class)
0294: protected List<Float> fixed3X3;
0295: @XmlList
0296: @XmlElement(name="float4x4",type=Float.class)
0297: protected List<Float> float4X4;
0298: @XmlList
0299: @XmlElement(name="fixed2x1",type=Float.class)
0300: protected List<Float> fixed2X1;
0301: protected Float fixed;
0302: @XmlList
0303: @XmlElement(name="bool4x1",type=Boolean.class)
0304: protected List<Boolean> bool4X1;
0305: @XmlList
0306: @XmlElement(name="float4x3",type=Float.class)
0307: protected List<Float> float4X3;
0308: @XmlList
0309: @XmlElement(name="int4x1",type=Integer.class)
0310: protected List<Integer> int4X1;
0311: @XmlList
0312: @XmlElement(name="float3x3",type=Float.class)
0313: protected List<Float> float3X3;
0314: @XmlList
0315: @XmlElement(name="bool4x4",type=Boolean.class)
0316: protected List<Boolean> bool4X4;
0317: @XmlList
0318: @XmlElement(name="fixed3x4",type=Float.class)
0319: protected List<Float> fixed3X4;
0320: @XmlList
0321: @XmlElement(name="half2x2",type=Float.class)
0322: protected List<Float> half2X2;
0323: @XmlList
0324: @XmlElement(name="half4x4",type=Float.class)
0325: protected List<Float> half4X4;
0326: @XmlList
0327: @XmlElement(name="half3x1",type=Float.class)
0328: protected List<Float> half3X1;
0329: @XmlList
0330: @XmlElement(name="int3x2",type=Integer.class)
0331: protected List<Integer> int3X2;
0332: @XmlList
0333: @XmlElement(type=Integer.class)
0334: protected List<Integer> int2;
0335: @XmlList
0336: @XmlElement(name="float2x1",type=Float.class)
0337: protected List<Float> float2X1;
0338: @XmlList
0339: @XmlElement(name="half4x2",type=Float.class)
0340: protected List<Float> half4X2;
0341: @XmlList
0342: @XmlElement(name="half3x4",type=Float.class)
0343: protected List<Float> half3X4;
0344: protected Float half;
0345: @XmlList
0346: @XmlElement(name="fixed4x4",type=Float.class)
0347: protected List<Float> fixed4X4;
0348: @XmlList
0349: @XmlElement(name="bool3x2",type=Boolean.class)
0350: protected List<Boolean> bool3X2;
0351: @XmlList
0352: @XmlElement(type=Float.class)
0353: protected List<Float> float3;
0354: @XmlList
0355: @XmlElement(name="bool4x3",type=Boolean.class)
0356: protected List<Boolean> bool4X3;
0357: protected CgSetarrayType array;
0358: @XmlList
0359: @XmlElement(name="fixed1x2",type=Float.class)
0360: protected List<Float> fixed1X2;
0361: protected CgSampler2D sampler2D;
0362: @XmlElement(name="float")
0363: protected Float _float;
0364: @XmlAttribute
0365: @XmlJavaTypeAdapter(CollapsedStringAdapter.class)
0366: protected String program;
0367: @XmlAttribute(required=true)
0368: @XmlJavaTypeAdapter(CollapsedStringAdapter.class)
0369: protected String ref;
0370:
0371: /**
0372: * Gets the value of the int4X3 property.
0373: *
0374: * <p>
0375: * This accessor method returns a reference to the live list,
0376: * not a snapshot. Therefore any modification you make to the
0377: * returned list will be present inside the JAXB object.
0378: * This is why there is not a <CODE>set</CODE> method for the int4X3 property.
0379: *
0380: * <p>
0381: * For example, to add a new item, do as follows:
0382: * <pre>
0383: * getInt4X3().add(newItem);
0384: * </pre>
0385: *
0386: *
0387: * <p>
0388: * Objects of the following type(s) are allowed in the list
0389: * {@link Integer }
0390: *
0391: *
0392: */
0393: public List<Integer> getInt4X3() {
0394: if (int4X3 == null) {
0395: int4X3 = new ArrayList<Integer>();
0396: }
0397: return this .int4X3;
0398: }
0399:
0400: /**
0401: * Gets the value of the half3X3 property.
0402: *
0403: * <p>
0404: * This accessor method returns a reference to the live list,
0405: * not a snapshot. Therefore any modification you make to the
0406: * returned list will be present inside the JAXB object.
0407: * This is why there is not a <CODE>set</CODE> method for the half3X3 property.
0408: *
0409: * <p>
0410: * For example, to add a new item, do as follows:
0411: * <pre>
0412: * getHalf3X3().add(newItem);
0413: * </pre>
0414: *
0415: *
0416: * <p>
0417: * Objects of the following type(s) are allowed in the list
0418: * {@link Float }
0419: *
0420: *
0421: */
0422: public List<Float> getHalf3X3() {
0423: if (half3X3 == null) {
0424: half3X3 = new ArrayList<Float>();
0425: }
0426: return this .half3X3;
0427: }
0428:
0429: /**
0430: * Gets the value of the fixed1X1 property.
0431: *
0432: * <p>
0433: * This accessor method returns a reference to the live list,
0434: * not a snapshot. Therefore any modification you make to the
0435: * returned list will be present inside the JAXB object.
0436: * This is why there is not a <CODE>set</CODE> method for the fixed1X1 property.
0437: *
0438: * <p>
0439: * For example, to add a new item, do as follows:
0440: * <pre>
0441: * getFixed1X1().add(newItem);
0442: * </pre>
0443: *
0444: *
0445: * <p>
0446: * Objects of the following type(s) are allowed in the list
0447: * {@link Float }
0448: *
0449: *
0450: */
0451: public List<Float> getFixed1X1() {
0452: if (fixed1X1 == null) {
0453: fixed1X1 = new ArrayList<Float>();
0454: }
0455: return this .fixed1X1;
0456: }
0457:
0458: /**
0459: * Gets the value of the bool2X1 property.
0460: *
0461: * <p>
0462: * This accessor method returns a reference to the live list,
0463: * not a snapshot. Therefore any modification you make to the
0464: * returned list will be present inside the JAXB object.
0465: * This is why there is not a <CODE>set</CODE> method for the bool2X1 property.
0466: *
0467: * <p>
0468: * For example, to add a new item, do as follows:
0469: * <pre>
0470: * getBool2X1().add(newItem);
0471: * </pre>
0472: *
0473: *
0474: * <p>
0475: * Objects of the following type(s) are allowed in the list
0476: * {@link Boolean }
0477: *
0478: *
0479: */
0480: public List<Boolean> getBool2X1() {
0481: if (bool2X1 == null) {
0482: bool2X1 = new ArrayList<Boolean>();
0483: }
0484: return this .bool2X1;
0485: }
0486:
0487: /**
0488: * Gets the value of the bool2X3 property.
0489: *
0490: * <p>
0491: * This accessor method returns a reference to the live list,
0492: * not a snapshot. Therefore any modification you make to the
0493: * returned list will be present inside the JAXB object.
0494: * This is why there is not a <CODE>set</CODE> method for the bool2X3 property.
0495: *
0496: * <p>
0497: * For example, to add a new item, do as follows:
0498: * <pre>
0499: * getBool2X3().add(newItem);
0500: * </pre>
0501: *
0502: *
0503: * <p>
0504: * Objects of the following type(s) are allowed in the list
0505: * {@link Boolean }
0506: *
0507: *
0508: */
0509: public List<Boolean> getBool2X3() {
0510: if (bool2X3 == null) {
0511: bool2X3 = new ArrayList<Boolean>();
0512: }
0513: return this .bool2X3;
0514: }
0515:
0516: /**
0517: * Gets the value of the fixed1X3 property.
0518: *
0519: * <p>
0520: * This accessor method returns a reference to the live list,
0521: * not a snapshot. Therefore any modification you make to the
0522: * returned list will be present inside the JAXB object.
0523: * This is why there is not a <CODE>set</CODE> method for the fixed1X3 property.
0524: *
0525: * <p>
0526: * For example, to add a new item, do as follows:
0527: * <pre>
0528: * getFixed1X3().add(newItem);
0529: * </pre>
0530: *
0531: *
0532: * <p>
0533: * Objects of the following type(s) are allowed in the list
0534: * {@link Float }
0535: *
0536: *
0537: */
0538: public List<Float> getFixed1X3() {
0539: if (fixed1X3 == null) {
0540: fixed1X3 = new ArrayList<Float>();
0541: }
0542: return this .fixed1X3;
0543: }
0544:
0545: /**
0546: * Gets the value of the half2 property.
0547: *
0548: * <p>
0549: * This accessor method returns a reference to the live list,
0550: * not a snapshot. Therefore any modification you make to the
0551: * returned list will be present inside the JAXB object.
0552: * This is why there is not a <CODE>set</CODE> method for the half2 property.
0553: *
0554: * <p>
0555: * For example, to add a new item, do as follows:
0556: * <pre>
0557: * getHalf2().add(newItem);
0558: * </pre>
0559: *
0560: *
0561: * <p>
0562: * Objects of the following type(s) are allowed in the list
0563: * {@link Float }
0564: *
0565: *
0566: */
0567: public List<Float> getHalf2() {
0568: if (half2 == null) {
0569: half2 = new ArrayList<Float>();
0570: }
0571: return this .half2;
0572: }
0573:
0574: /**
0575: * Gets the value of the surface property.
0576: *
0577: * @return
0578: * possible object is
0579: * {@link CgSurfaceType }
0580: *
0581: */
0582: public CgSurfaceType getSurface() {
0583: return surface;
0584: }
0585:
0586: /**
0587: * Sets the value of the surface property.
0588: *
0589: * @param value
0590: * allowed object is
0591: * {@link CgSurfaceType }
0592: *
0593: */
0594: public void setSurface(CgSurfaceType value) {
0595: this .surface = value;
0596: }
0597:
0598: /**
0599: * Gets the value of the float1 property.
0600: *
0601: * @return
0602: * possible object is
0603: * {@link Float }
0604: *
0605: */
0606: public Float getFloat1() {
0607: return float1;
0608: }
0609:
0610: /**
0611: * Sets the value of the float1 property.
0612: *
0613: * @param value
0614: * allowed object is
0615: * {@link Float }
0616: *
0617: */
0618: public void setFloat1(Float value) {
0619: this .float1 = value;
0620: }
0621:
0622: /**
0623: * Gets the value of the half1 property.
0624: *
0625: * @return
0626: * possible object is
0627: * {@link Float }
0628: *
0629: */
0630: public Float getHalf1() {
0631: return half1;
0632: }
0633:
0634: /**
0635: * Sets the value of the half1 property.
0636: *
0637: * @param value
0638: * allowed object is
0639: * {@link Float }
0640: *
0641: */
0642: public void setHalf1(Float value) {
0643: this .half1 = value;
0644: }
0645:
0646: /**
0647: * Gets the value of the fixed2 property.
0648: *
0649: * <p>
0650: * This accessor method returns a reference to the live list,
0651: * not a snapshot. Therefore any modification you make to the
0652: * returned list will be present inside the JAXB object.
0653: * This is why there is not a <CODE>set</CODE> method for the fixed2 property.
0654: *
0655: * <p>
0656: * For example, to add a new item, do as follows:
0657: * <pre>
0658: * getFixed2().add(newItem);
0659: * </pre>
0660: *
0661: *
0662: * <p>
0663: * Objects of the following type(s) are allowed in the list
0664: * {@link Float }
0665: *
0666: *
0667: */
0668: public List<Float> getFixed2() {
0669: if (fixed2 == null) {
0670: fixed2 = new ArrayList<Float>();
0671: }
0672: return this .fixed2;
0673: }
0674:
0675: /**
0676: * Gets the value of the fixed4X3 property.
0677: *
0678: * <p>
0679: * This accessor method returns a reference to the live list,
0680: * not a snapshot. Therefore any modification you make to the
0681: * returned list will be present inside the JAXB object.
0682: * This is why there is not a <CODE>set</CODE> method for the fixed4X3 property.
0683: *
0684: * <p>
0685: * For example, to add a new item, do as follows:
0686: * <pre>
0687: * getFixed4X3().add(newItem);
0688: * </pre>
0689: *
0690: *
0691: * <p>
0692: * Objects of the following type(s) are allowed in the list
0693: * {@link Float }
0694: *
0695: *
0696: */
0697: public List<Float> getFixed4X3() {
0698: if (fixed4X3 == null) {
0699: fixed4X3 = new ArrayList<Float>();
0700: }
0701: return this .fixed4X3;
0702: }
0703:
0704: /**
0705: * Gets the value of the bool2 property.
0706: *
0707: * <p>
0708: * This accessor method returns a reference to the live list,
0709: * not a snapshot. Therefore any modification you make to the
0710: * returned list will be present inside the JAXB object.
0711: * This is why there is not a <CODE>set</CODE> method for the bool2 property.
0712: *
0713: * <p>
0714: * For example, to add a new item, do as follows:
0715: * <pre>
0716: * getBool2().add(newItem);
0717: * </pre>
0718: *
0719: *
0720: * <p>
0721: * Objects of the following type(s) are allowed in the list
0722: * {@link Boolean }
0723: *
0724: *
0725: */
0726: public List<Boolean> getBool2() {
0727: if (bool2 == null) {
0728: bool2 = new ArrayList<Boolean>();
0729: }
0730: return this .bool2;
0731: }
0732:
0733: /**
0734: * Gets the value of the samplerRECT property.
0735: *
0736: * @return
0737: * possible object is
0738: * {@link CgSamplerRECT }
0739: *
0740: */
0741: public CgSamplerRECT getSamplerRECT() {
0742: return samplerRECT;
0743: }
0744:
0745: /**
0746: * Sets the value of the samplerRECT property.
0747: *
0748: * @param value
0749: * allowed object is
0750: * {@link CgSamplerRECT }
0751: *
0752: */
0753: public void setSamplerRECT(CgSamplerRECT value) {
0754: this .samplerRECT = value;
0755: }
0756:
0757: /**
0758: * Gets the value of the half1X4 property.
0759: *
0760: * <p>
0761: * This accessor method returns a reference to the live list,
0762: * not a snapshot. Therefore any modification you make to the
0763: * returned list will be present inside the JAXB object.
0764: * This is why there is not a <CODE>set</CODE> method for the half1X4 property.
0765: *
0766: * <p>
0767: * For example, to add a new item, do as follows:
0768: * <pre>
0769: * getHalf1X4().add(newItem);
0770: * </pre>
0771: *
0772: *
0773: * <p>
0774: * Objects of the following type(s) are allowed in the list
0775: * {@link Float }
0776: *
0777: *
0778: */
0779: public List<Float> getHalf1X4() {
0780: if (half1X4 == null) {
0781: half1X4 = new ArrayList<Float>();
0782: }
0783: return this .half1X4;
0784: }
0785:
0786: /**
0787: * Gets the value of the bool2X4 property.
0788: *
0789: * <p>
0790: * This accessor method returns a reference to the live list,
0791: * not a snapshot. Therefore any modification you make to the
0792: * returned list will be present inside the JAXB object.
0793: * This is why there is not a <CODE>set</CODE> method for the bool2X4 property.
0794: *
0795: * <p>
0796: * For example, to add a new item, do as follows:
0797: * <pre>
0798: * getBool2X4().add(newItem);
0799: * </pre>
0800: *
0801: *
0802: * <p>
0803: * Objects of the following type(s) are allowed in the list
0804: * {@link Boolean }
0805: *
0806: *
0807: */
0808: public List<Boolean> getBool2X4() {
0809: if (bool2X4 == null) {
0810: bool2X4 = new ArrayList<Boolean>();
0811: }
0812: return this .bool2X4;
0813: }
0814:
0815: /**
0816: * Gets the value of the usertype property.
0817: *
0818: * @return
0819: * possible object is
0820: * {@link CgSetuserType }
0821: *
0822: */
0823: public CgSetuserType getUsertype() {
0824: return usertype;
0825: }
0826:
0827: /**
0828: * Sets the value of the usertype property.
0829: *
0830: * @param value
0831: * allowed object is
0832: * {@link CgSetuserType }
0833: *
0834: */
0835: public void setUsertype(CgSetuserType value) {
0836: this .usertype = value;
0837: }
0838:
0839: /**
0840: * Gets the value of the fixed4X1 property.
0841: *
0842: * <p>
0843: * This accessor method returns a reference to the live list,
0844: * not a snapshot. Therefore any modification you make to the
0845: * returned list will be present inside the JAXB object.
0846: * This is why there is not a <CODE>set</CODE> method for the fixed4X1 property.
0847: *
0848: * <p>
0849: * For example, to add a new item, do as follows:
0850: * <pre>
0851: * getFixed4X1().add(newItem);
0852: * </pre>
0853: *
0854: *
0855: * <p>
0856: * Objects of the following type(s) are allowed in the list
0857: * {@link Float }
0858: *
0859: *
0860: */
0861: public List<Float> getFixed4X1() {
0862: if (fixed4X1 == null) {
0863: fixed4X1 = new ArrayList<Float>();
0864: }
0865: return this .fixed4X1;
0866: }
0867:
0868: /**
0869: * Gets the value of the fixed1 property.
0870: *
0871: * @return
0872: * possible object is
0873: * {@link Float }
0874: *
0875: */
0876: public Float getFixed1() {
0877: return fixed1;
0878: }
0879:
0880: /**
0881: * Sets the value of the fixed1 property.
0882: *
0883: * @param value
0884: * allowed object is
0885: * {@link Float }
0886: *
0887: */
0888: public void setFixed1(Float value) {
0889: this .fixed1 = value;
0890: }
0891:
0892: /**
0893: * Gets the value of the bool4 property.
0894: *
0895: * <p>
0896: * This accessor method returns a reference to the live list,
0897: * not a snapshot. Therefore any modification you make to the
0898: * returned list will be present inside the JAXB object.
0899: * This is why there is not a <CODE>set</CODE> method for the bool4 property.
0900: *
0901: * <p>
0902: * For example, to add a new item, do as follows:
0903: * <pre>
0904: * getBool4().add(newItem);
0905: * </pre>
0906: *
0907: *
0908: * <p>
0909: * Objects of the following type(s) are allowed in the list
0910: * {@link Boolean }
0911: *
0912: *
0913: */
0914: public List<Boolean> getBool4() {
0915: if (bool4 == null) {
0916: bool4 = new ArrayList<Boolean>();
0917: }
0918: return this .bool4;
0919: }
0920:
0921: /**
0922: * Gets the value of the int2X2 property.
0923: *
0924: * <p>
0925: * This accessor method returns a reference to the live list,
0926: * not a snapshot. Therefore any modification you make to the
0927: * returned list will be present inside the JAXB object.
0928: * This is why there is not a <CODE>set</CODE> method for the int2X2 property.
0929: *
0930: * <p>
0931: * For example, to add a new item, do as follows:
0932: * <pre>
0933: * getInt2X2().add(newItem);
0934: * </pre>
0935: *
0936: *
0937: * <p>
0938: * Objects of the following type(s) are allowed in the list
0939: * {@link Integer }
0940: *
0941: *
0942: */
0943: public List<Integer> getInt2X2() {
0944: if (int2X2 == null) {
0945: int2X2 = new ArrayList<Integer>();
0946: }
0947: return this .int2X2;
0948: }
0949:
0950: /**
0951: * Gets the value of the int1X1 property.
0952: *
0953: * <p>
0954: * This accessor method returns a reference to the live list,
0955: * not a snapshot. Therefore any modification you make to the
0956: * returned list will be present inside the JAXB object.
0957: * This is why there is not a <CODE>set</CODE> method for the int1X1 property.
0958: *
0959: * <p>
0960: * For example, to add a new item, do as follows:
0961: * <pre>
0962: * getInt1X1().add(newItem);
0963: * </pre>
0964: *
0965: *
0966: * <p>
0967: * Objects of the following type(s) are allowed in the list
0968: * {@link Integer }
0969: *
0970: *
0971: */
0972: public List<Integer> getInt1X1() {
0973: if (int1X1 == null) {
0974: int1X1 = new ArrayList<Integer>();
0975: }
0976: return this .int1X1;
0977: }
0978:
0979: /**
0980: * Gets the value of the sampler1D property.
0981: *
0982: * @return
0983: * possible object is
0984: * {@link CgSampler1D }
0985: *
0986: */
0987: public CgSampler1D getSampler1D() {
0988: return sampler1D;
0989: }
0990:
0991: /**
0992: * Sets the value of the sampler1D property.
0993: *
0994: * @param value
0995: * allowed object is
0996: * {@link CgSampler1D }
0997: *
0998: */
0999: public void setSampler1D(CgSampler1D value) {
1000: this .sampler1D = value;
1001: }
1002:
1003: /**
1004: * Gets the value of the half4 property.
1005: *
1006: * <p>
1007: * This accessor method returns a reference to the live list,
1008: * not a snapshot. Therefore any modification you make to the
1009: * returned list will be present inside the JAXB object.
1010: * This is why there is not a <CODE>set</CODE> method for the half4 property.
1011: *
1012: * <p>
1013: * For example, to add a new item, do as follows:
1014: * <pre>
1015: * getHalf4().add(newItem);
1016: * </pre>
1017: *
1018: *
1019: * <p>
1020: * Objects of the following type(s) are allowed in the list
1021: * {@link Float }
1022: *
1023: *
1024: */
1025: public List<Float> getHalf4() {
1026: if (half4 == null) {
1027: half4 = new ArrayList<Float>();
1028: }
1029: return this .half4;
1030: }
1031:
1032: /**
1033: * Gets the value of the bool4X2 property.
1034: *
1035: * <p>
1036: * This accessor method returns a reference to the live list,
1037: * not a snapshot. Therefore any modification you make to the
1038: * returned list will be present inside the JAXB object.
1039: * This is why there is not a <CODE>set</CODE> method for the bool4X2 property.
1040: *
1041: * <p>
1042: * For example, to add a new item, do as follows:
1043: * <pre>
1044: * getBool4X2().add(newItem);
1045: * </pre>
1046: *
1047: *
1048: * <p>
1049: * Objects of the following type(s) are allowed in the list
1050: * {@link Boolean }
1051: *
1052: *
1053: */
1054: public List<Boolean> getBool4X2() {
1055: if (bool4X2 == null) {
1056: bool4X2 = new ArrayList<Boolean>();
1057: }
1058: return this .bool4X2;
1059: }
1060:
1061: /**
1062: * Gets the value of the int3 property.
1063: *
1064: * <p>
1065: * This accessor method returns a reference to the live list,
1066: * not a snapshot. Therefore any modification you make to the
1067: * returned list will be present inside the JAXB object.
1068: * This is why there is not a <CODE>set</CODE> method for the int3 property.
1069: *
1070: * <p>
1071: * For example, to add a new item, do as follows:
1072: * <pre>
1073: * getInt3().add(newItem);
1074: * </pre>
1075: *
1076: *
1077: * <p>
1078: * Objects of the following type(s) are allowed in the list
1079: * {@link Integer }
1080: *
1081: *
1082: */
1083: public List<Integer> getInt3() {
1084: if (int3 == null) {
1085: int3 = new ArrayList<Integer>();
1086: }
1087: return this .int3;
1088: }
1089:
1090: /**
1091: * Gets the value of the float4X2 property.
1092: *
1093: * <p>
1094: * This accessor method returns a reference to the live list,
1095: * not a snapshot. Therefore any modification you make to the
1096: * returned list will be present inside the JAXB object.
1097: * This is why there is not a <CODE>set</CODE> method for the float4X2 property.
1098: *
1099: * <p>
1100: * For example, to add a new item, do as follows:
1101: * <pre>
1102: * getFloat4X2().add(newItem);
1103: * </pre>
1104: *
1105: *
1106: * <p>
1107: * Objects of the following type(s) are allowed in the list
1108: * {@link Float }
1109: *
1110: *
1111: */
1112: public List<Float> getFloat4X2() {
1113: if (float4X2 == null) {
1114: float4X2 = new ArrayList<Float>();
1115: }
1116: return this .float4X2;
1117: }
1118:
1119: /**
1120: * Gets the value of the float2X3 property.
1121: *
1122: * <p>
1123: * This accessor method returns a reference to the live list,
1124: * not a snapshot. Therefore any modification you make to the
1125: * returned list will be present inside the JAXB object.
1126: * This is why there is not a <CODE>set</CODE> method for the float2X3 property.
1127: *
1128: * <p>
1129: * For example, to add a new item, do as follows:
1130: * <pre>
1131: * getFloat2X3().add(newItem);
1132: * </pre>
1133: *
1134: *
1135: * <p>
1136: * Objects of the following type(s) are allowed in the list
1137: * {@link Float }
1138: *
1139: *
1140: */
1141: public List<Float> getFloat2X3() {
1142: if (float2X3 == null) {
1143: float2X3 = new ArrayList<Float>();
1144: }
1145: return this .float2X3;
1146: }
1147:
1148: /**
1149: * Gets the value of the bool1X3 property.
1150: *
1151: * <p>
1152: * This accessor method returns a reference to the live list,
1153: * not a snapshot. Therefore any modification you make to the
1154: * returned list will be present inside the JAXB object.
1155: * This is why there is not a <CODE>set</CODE> method for the bool1X3 property.
1156: *
1157: * <p>
1158: * For example, to add a new item, do as follows:
1159: * <pre>
1160: * getBool1X3().add(newItem);
1161: * </pre>
1162: *
1163: *
1164: * <p>
1165: * Objects of the following type(s) are allowed in the list
1166: * {@link Boolean }
1167: *
1168: *
1169: */
1170: public List<Boolean> getBool1X3() {
1171: if (bool1X3 == null) {
1172: bool1X3 = new ArrayList<Boolean>();
1173: }
1174: return this .bool1X3;
1175: }
1176:
1177: /**
1178: * Gets the value of the half2X1 property.
1179: *
1180: * <p>
1181: * This accessor method returns a reference to the live list,
1182: * not a snapshot. Therefore any modification you make to the
1183: * returned list will be present inside the JAXB object.
1184: * This is why there is not a <CODE>set</CODE> method for the half2X1 property.
1185: *
1186: * <p>
1187: * For example, to add a new item, do as follows:
1188: * <pre>
1189: * getHalf2X1().add(newItem);
1190: * </pre>
1191: *
1192: *
1193: * <p>
1194: * Objects of the following type(s) are allowed in the list
1195: * {@link Float }
1196: *
1197: *
1198: */
1199: public List<Float> getHalf2X1() {
1200: if (half2X1 == null) {
1201: half2X1 = new ArrayList<Float>();
1202: }
1203: return this .half2X1;
1204: }
1205:
1206: /**
1207: * Gets the value of the samplerDEPTH property.
1208: *
1209: * @return
1210: * possible object is
1211: * {@link CgSamplerDEPTH }
1212: *
1213: */
1214: public CgSamplerDEPTH getSamplerDEPTH() {
1215: return samplerDEPTH;
1216: }
1217:
1218: /**
1219: * Sets the value of the samplerDEPTH property.
1220: *
1221: * @param value
1222: * allowed object is
1223: * {@link CgSamplerDEPTH }
1224: *
1225: */
1226: public void setSamplerDEPTH(CgSamplerDEPTH value) {
1227: this .samplerDEPTH = value;
1228: }
1229:
1230: /**
1231: * Gets the value of the int3X4 property.
1232: *
1233: * <p>
1234: * This accessor method returns a reference to the live list,
1235: * not a snapshot. Therefore any modification you make to the
1236: * returned list will be present inside the JAXB object.
1237: * This is why there is not a <CODE>set</CODE> method for the int3X4 property.
1238: *
1239: * <p>
1240: * For example, to add a new item, do as follows:
1241: * <pre>
1242: * getInt3X4().add(newItem);
1243: * </pre>
1244: *
1245: *
1246: * <p>
1247: * Objects of the following type(s) are allowed in the list
1248: * {@link Integer }
1249: *
1250: *
1251: */
1252: public List<Integer> getInt3X4() {
1253: if (int3X4 == null) {
1254: int3X4 = new ArrayList<Integer>();
1255: }
1256: return this .int3X4;
1257: }
1258:
1259: /**
1260: * Gets the value of the int3X1 property.
1261: *
1262: * <p>
1263: * This accessor method returns a reference to the live list,
1264: * not a snapshot. Therefore any modification you make to the
1265: * returned list will be present inside the JAXB object.
1266: * This is why there is not a <CODE>set</CODE> method for the int3X1 property.
1267: *
1268: * <p>
1269: * For example, to add a new item, do as follows:
1270: * <pre>
1271: * getInt3X1().add(newItem);
1272: * </pre>
1273: *
1274: *
1275: * <p>
1276: * Objects of the following type(s) are allowed in the list
1277: * {@link Integer }
1278: *
1279: *
1280: */
1281: public List<Integer> getInt3X1() {
1282: if (int3X1 == null) {
1283: int3X1 = new ArrayList<Integer>();
1284: }
1285: return this .int3X1;
1286: }
1287:
1288: /**
1289: * Gets the value of the fixed2X4 property.
1290: *
1291: * <p>
1292: * This accessor method returns a reference to the live list,
1293: * not a snapshot. Therefore any modification you make to the
1294: * returned list will be present inside the JAXB object.
1295: * This is why there is not a <CODE>set</CODE> method for the fixed2X4 property.
1296: *
1297: * <p>
1298: * For example, to add a new item, do as follows:
1299: * <pre>
1300: * getFixed2X4().add(newItem);
1301: * </pre>
1302: *
1303: *
1304: * <p>
1305: * Objects of the following type(s) are allowed in the list
1306: * {@link Float }
1307: *
1308: *
1309: */
1310: public List<Float> getFixed2X4() {
1311: if (fixed2X4 == null) {
1312: fixed2X4 = new ArrayList<Float>();
1313: }
1314: return this .fixed2X4;
1315: }
1316:
1317: /**
1318: * Gets the value of the sampler3D property.
1319: *
1320: * @return
1321: * possible object is
1322: * {@link CgSampler3D }
1323: *
1324: */
1325: public CgSampler3D getSampler3D() {
1326: return sampler3D;
1327: }
1328:
1329: /**
1330: * Sets the value of the sampler3D property.
1331: *
1332: * @param value
1333: * allowed object is
1334: * {@link CgSampler3D }
1335: *
1336: */
1337: public void setSampler3D(CgSampler3D value) {
1338: this .sampler3D = value;
1339: }
1340:
1341: /**
1342: * Gets the value of the half1X2 property.
1343: *
1344: * <p>
1345: * This accessor method returns a reference to the live list,
1346: * not a snapshot. Therefore any modification you make to the
1347: * returned list will be present inside the JAXB object.
1348: * This is why there is not a <CODE>set</CODE> method for the half1X2 property.
1349: *
1350: * <p>
1351: * For example, to add a new item, do as follows:
1352: * <pre>
1353: * getHalf1X2().add(newItem);
1354: * </pre>
1355: *
1356: *
1357: * <p>
1358: * Objects of the following type(s) are allowed in the list
1359: * {@link Float }
1360: *
1361: *
1362: */
1363: public List<Float> getHalf1X2() {
1364: if (half1X2 == null) {
1365: half1X2 = new ArrayList<Float>();
1366: }
1367: return this .half1X2;
1368: }
1369:
1370: /**
1371: * Gets the value of the int4 property.
1372: *
1373: * <p>
1374: * This accessor method returns a reference to the live list,
1375: * not a snapshot. Therefore any modification you make to the
1376: * returned list will be present inside the JAXB object.
1377: * This is why there is not a <CODE>set</CODE> method for the int4 property.
1378: *
1379: * <p>
1380: * For example, to add a new item, do as follows:
1381: * <pre>
1382: * getInt4().add(newItem);
1383: * </pre>
1384: *
1385: *
1386: * <p>
1387: * Objects of the following type(s) are allowed in the list
1388: * {@link Integer }
1389: *
1390: *
1391: */
1392: public List<Integer> getInt4() {
1393: if (int4 == null) {
1394: int4 = new ArrayList<Integer>();
1395: }
1396: return this .int4;
1397: }
1398:
1399: /**
1400: * Gets the value of the bool3X3 property.
1401: *
1402: * <p>
1403: * This accessor method returns a reference to the live list,
1404: * not a snapshot. Therefore any modification you make to the
1405: * returned list will be present inside the JAXB object.
1406: * This is why there is not a <CODE>set</CODE> method for the bool3X3 property.
1407: *
1408: * <p>
1409: * For example, to add a new item, do as follows:
1410: * <pre>
1411: * getBool3X3().add(newItem);
1412: * </pre>
1413: *
1414: *
1415: * <p>
1416: * Objects of the following type(s) are allowed in the list
1417: * {@link Boolean }
1418: *
1419: *
1420: */
1421: public List<Boolean> getBool3X3() {
1422: if (bool3X3 == null) {
1423: bool3X3 = new ArrayList<Boolean>();
1424: }
1425: return this .bool3X3;
1426: }
1427:
1428: /**
1429: * Gets the value of the bool1X4 property.
1430: *
1431: * <p>
1432: * This accessor method returns a reference to the live list,
1433: * not a snapshot. Therefore any modification you make to the
1434: * returned list will be present inside the JAXB object.
1435: * This is why there is not a <CODE>set</CODE> method for the bool1X4 property.
1436: *
1437: * <p>
1438: * For example, to add a new item, do as follows:
1439: * <pre>
1440: * getBool1X4().add(newItem);
1441: * </pre>
1442: *
1443: *
1444: * <p>
1445: * Objects of the following type(s) are allowed in the list
1446: * {@link Boolean }
1447: *
1448: *
1449: */
1450: public List<Boolean> getBool1X4() {
1451: if (bool1X4 == null) {
1452: bool1X4 = new ArrayList<Boolean>();
1453: }
1454: return this .bool1X4;
1455: }
1456:
1457: /**
1458: * Gets the value of the bool2X2 property.
1459: *
1460: * <p>
1461: * This accessor method returns a reference to the live list,
1462: * not a snapshot. Therefore any modification you make to the
1463: * returned list will be present inside the JAXB object.
1464: * This is why there is not a <CODE>set</CODE> method for the bool2X2 property.
1465: *
1466: * <p>
1467: * For example, to add a new item, do as follows:
1468: * <pre>
1469: * getBool2X2().add(newItem);
1470: * </pre>
1471: *
1472: *
1473: * <p>
1474: * Objects of the following type(s) are allowed in the list
1475: * {@link Boolean }
1476: *
1477: *
1478: */
1479: public List<Boolean> getBool2X2() {
1480: if (bool2X2 == null) {
1481: bool2X2 = new ArrayList<Boolean>();
1482: }
1483: return this .bool2X2;
1484: }
1485:
1486: /**
1487: * Gets the value of the float1X4 property.
1488: *
1489: * <p>
1490: * This accessor method returns a reference to the live list,
1491: * not a snapshot. Therefore any modification you make to the
1492: * returned list will be present inside the JAXB object.
1493: * This is why there is not a <CODE>set</CODE> method for the float1X4 property.
1494: *
1495: * <p>
1496: * For example, to add a new item, do as follows:
1497: * <pre>
1498: * getFloat1X4().add(newItem);
1499: * </pre>
1500: *
1501: *
1502: * <p>
1503: * Objects of the following type(s) are allowed in the list
1504: * {@link Float }
1505: *
1506: *
1507: */
1508: public List<Float> getFloat1X4() {
1509: if (float1X4 == null) {
1510: float1X4 = new ArrayList<Float>();
1511: }
1512: return this .float1X4;
1513: }
1514:
1515: /**
1516: * Gets the value of the float3X4 property.
1517: *
1518: * <p>
1519: * This accessor method returns a reference to the live list,
1520: * not a snapshot. Therefore any modification you make to the
1521: * returned list will be present inside the JAXB object.
1522: * This is why there is not a <CODE>set</CODE> method for the float3X4 property.
1523: *
1524: * <p>
1525: * For example, to add a new item, do as follows:
1526: * <pre>
1527: * getFloat3X4().add(newItem);
1528: * </pre>
1529: *
1530: *
1531: * <p>
1532: * Objects of the following type(s) are allowed in the list
1533: * {@link Float }
1534: *
1535: *
1536: */
1537: public List<Float> getFloat3X4() {
1538: if (float3X4 == null) {
1539: float3X4 = new ArrayList<Float>();
1540: }
1541: return this .float3X4;
1542: }
1543:
1544: /**
1545: * Gets the value of the fixed2X2 property.
1546: *
1547: * <p>
1548: * This accessor method returns a reference to the live list,
1549: * not a snapshot. Therefore any modification you make to the
1550: * returned list will be present inside the JAXB object.
1551: * This is why there is not a <CODE>set</CODE> method for the fixed2X2 property.
1552: *
1553: * <p>
1554: * For example, to add a new item, do as follows:
1555: * <pre>
1556: * getFixed2X2().add(newItem);
1557: * </pre>
1558: *
1559: *
1560: * <p>
1561: * Objects of the following type(s) are allowed in the list
1562: * {@link Float }
1563: *
1564: *
1565: */
1566: public List<Float> getFixed2X2() {
1567: if (fixed2X2 == null) {
1568: fixed2X2 = new ArrayList<Float>();
1569: }
1570: return this .fixed2X2;
1571: }
1572:
1573: /**
1574: * Gets the value of the int4X2 property.
1575: *
1576: * <p>
1577: * This accessor method returns a reference to the live list,
1578: * not a snapshot. Therefore any modification you make to the
1579: * returned list will be present inside the JAXB object.
1580: * This is why there is not a <CODE>set</CODE> method for the int4X2 property.
1581: *
1582: * <p>
1583: * For example, to add a new item, do as follows:
1584: * <pre>
1585: * getInt4X2().add(newItem);
1586: * </pre>
1587: *
1588: *
1589: * <p>
1590: * Objects of the following type(s) are allowed in the list
1591: * {@link Integer }
1592: *
1593: *
1594: */
1595: public List<Integer> getInt4X2() {
1596: if (int4X2 == null) {
1597: int4X2 = new ArrayList<Integer>();
1598: }
1599: return this .int4X2;
1600: }
1601:
1602: /**
1603: * Gets the value of the bool1 property.
1604: *
1605: * @return
1606: * possible object is
1607: * {@link Boolean }
1608: *
1609: */
1610: public Boolean isBool1() {
1611: return bool1;
1612: }
1613:
1614: /**
1615: * Sets the value of the bool1 property.
1616: *
1617: * @param value
1618: * allowed object is
1619: * {@link Boolean }
1620: *
1621: */
1622: public void setBool1(Boolean value) {
1623: this .bool1 = value;
1624: }
1625:
1626: /**
1627: * Gets the value of the float1X1 property.
1628: *
1629: * <p>
1630: * This accessor method returns a reference to the live list,
1631: * not a snapshot. Therefore any modification you make to the
1632: * returned list will be present inside the JAXB object.
1633: * This is why there is not a <CODE>set</CODE> method for the float1X1 property.
1634: *
1635: * <p>
1636: * For example, to add a new item, do as follows:
1637: * <pre>
1638: * getFloat1X1().add(newItem);
1639: * </pre>
1640: *
1641: *
1642: * <p>
1643: * Objects of the following type(s) are allowed in the list
1644: * {@link Float }
1645: *
1646: *
1647: */
1648: public List<Float> getFloat1X1() {
1649: if (float1X1 == null) {
1650: float1X1 = new ArrayList<Float>();
1651: }
1652: return this .float1X1;
1653: }
1654:
1655: /**
1656: * Gets the value of the half2X3 property.
1657: *
1658: * <p>
1659: * This accessor method returns a reference to the live list,
1660: * not a snapshot. Therefore any modification you make to the
1661: * returned list will be present inside the JAXB object.
1662: * This is why there is not a <CODE>set</CODE> method for the half2X3 property.
1663: *
1664: * <p>
1665: * For example, to add a new item, do as follows:
1666: * <pre>
1667: * getHalf2X3().add(newItem);
1668: * </pre>
1669: *
1670: *
1671: * <p>
1672: * Objects of the following type(s) are allowed in the list
1673: * {@link Float }
1674: *
1675: *
1676: */
1677: public List<Float> getHalf2X3() {
1678: if (half2X3 == null) {
1679: half2X3 = new ArrayList<Float>();
1680: }
1681: return this .half2X3;
1682: }
1683:
1684: /**
1685: * Gets the value of the connectParam property.
1686: *
1687: * @return
1688: * possible object is
1689: * {@link CgConnectParam }
1690: *
1691: */
1692: public CgConnectParam getConnectParam() {
1693: return connectParam;
1694: }
1695:
1696: /**
1697: * Sets the value of the connectParam property.
1698: *
1699: * @param value
1700: * allowed object is
1701: * {@link CgConnectParam }
1702: *
1703: */
1704: public void setConnectParam(CgConnectParam value) {
1705: this .connectParam = value;
1706: }
1707:
1708: /**
1709: * Gets the value of the int3X3 property.
1710: *
1711: * <p>
1712: * This accessor method returns a reference to the live list,
1713: * not a snapshot. Therefore any modification you make to the
1714: * returned list will be present inside the JAXB object.
1715: * This is why there is not a <CODE>set</CODE> method for the int3X3 property.
1716: *
1717: * <p>
1718: * For example, to add a new item, do as follows:
1719: * <pre>
1720: * getInt3X3().add(newItem);
1721: * </pre>
1722: *
1723: *
1724: * <p>
1725: * Objects of the following type(s) are allowed in the list
1726: * {@link Integer }
1727: *
1728: *
1729: */
1730: public List<Integer> getInt3X3() {
1731: if (int3X3 == null) {
1732: int3X3 = new ArrayList<Integer>();
1733: }
1734: return this .int3X3;
1735: }
1736:
1737: /**
1738: * Gets the value of the enum property.
1739: *
1740: * @return
1741: * possible object is
1742: * {@link String }
1743: *
1744: */
1745: public String getEnum() {
1746: return _enum;
1747: }
1748:
1749: /**
1750: * Sets the value of the enum property.
1751: *
1752: * @param value
1753: * allowed object is
1754: * {@link String }
1755: *
1756: */
1757: public void setEnum(String value) {
1758: this ._enum = value;
1759: }
1760:
1761: /**
1762: * Gets the value of the fixed3 property.
1763: *
1764: * <p>
1765: * This accessor method returns a reference to the live list,
1766: * not a snapshot. Therefore any modification you make to the
1767: * returned list will be present inside the JAXB object.
1768: * This is why there is not a <CODE>set</CODE> method for the fixed3 property.
1769: *
1770: * <p>
1771: * For example, to add a new item, do as follows:
1772: * <pre>
1773: * getFixed3().add(newItem);
1774: * </pre>
1775: *
1776: *
1777: * <p>
1778: * Objects of the following type(s) are allowed in the list
1779: * {@link Float }
1780: *
1781: *
1782: */
1783: public List<Float> getFixed3() {
1784: if (fixed3 == null) {
1785: fixed3 = new ArrayList<Float>();
1786: }
1787: return this .fixed3;
1788: }
1789:
1790: /**
1791: * Gets the value of the float1X2 property.
1792: *
1793: * <p>
1794: * This accessor method returns a reference to the live list,
1795: * not a snapshot. Therefore any modification you make to the
1796: * returned list will be present inside the JAXB object.
1797: * This is why there is not a <CODE>set</CODE> method for the float1X2 property.
1798: *
1799: * <p>
1800: * For example, to add a new item, do as follows:
1801: * <pre>
1802: * getFloat1X2().add(newItem);
1803: * </pre>
1804: *
1805: *
1806: * <p>
1807: * Objects of the following type(s) are allowed in the list
1808: * {@link Float }
1809: *
1810: *
1811: */
1812: public List<Float> getFloat1X2() {
1813: if (float1X2 == null) {
1814: float1X2 = new ArrayList<Float>();
1815: }
1816: return this .float1X2;
1817: }
1818:
1819: /**
1820: * Gets the value of the float3X1 property.
1821: *
1822: * <p>
1823: * This accessor method returns a reference to the live list,
1824: * not a snapshot. Therefore any modification you make to the
1825: * returned list will be present inside the JAXB object.
1826: * This is why there is not a <CODE>set</CODE> method for the float3X1 property.
1827: *
1828: * <p>
1829: * For example, to add a new item, do as follows:
1830: * <pre>
1831: * getFloat3X1().add(newItem);
1832: * </pre>
1833: *
1834: *
1835: * <p>
1836: * Objects of the following type(s) are allowed in the list
1837: * {@link Float }
1838: *
1839: *
1840: */
1841: public List<Float> getFloat3X1() {
1842: if (float3X1 == null) {
1843: float3X1 = new ArrayList<Float>();
1844: }
1845: return this .float3X1;
1846: }
1847:
1848: /**
1849: * Gets the value of the samplerCUBE property.
1850: *
1851: * @return
1852: * possible object is
1853: * {@link CgSamplerCUBE }
1854: *
1855: */
1856: public CgSamplerCUBE getSamplerCUBE() {
1857: return samplerCUBE;
1858: }
1859:
1860: /**
1861: * Sets the value of the samplerCUBE property.
1862: *
1863: * @param value
1864: * allowed object is
1865: * {@link CgSamplerCUBE }
1866: *
1867: */
1868: public void setSamplerCUBE(CgSamplerCUBE value) {
1869: this .samplerCUBE = value;
1870: }
1871:
1872: /**
1873: * Gets the value of the bool3X1 property.
1874: *
1875: * <p>
1876: * This accessor method returns a reference to the live list,
1877: * not a snapshot. Therefore any modification you make to the
1878: * returned list will be present inside the JAXB object.
1879: * This is why there is not a <CODE>set</CODE> method for the bool3X1 property.
1880: *
1881: * <p>
1882: * For example, to add a new item, do as follows:
1883: * <pre>
1884: * getBool3X1().add(newItem);
1885: * </pre>
1886: *
1887: *
1888: * <p>
1889: * Objects of the following type(s) are allowed in the list
1890: * {@link Boolean }
1891: *
1892: *
1893: */
1894: public List<Boolean> getBool3X1() {
1895: if (bool3X1 == null) {
1896: bool3X1 = new ArrayList<Boolean>();
1897: }
1898: return this .bool3X1;
1899: }
1900:
1901: /**
1902: * Gets the value of the bool property.
1903: *
1904: * @return
1905: * possible object is
1906: * {@link Boolean }
1907: *
1908: */
1909: public Boolean isBool() {
1910: return bool;
1911: }
1912:
1913: /**
1914: * Sets the value of the bool property.
1915: *
1916: * @param value
1917: * allowed object is
1918: * {@link Boolean }
1919: *
1920: */
1921: public void setBool(Boolean value) {
1922: this .bool = value;
1923: }
1924:
1925: /**
1926: * Gets the value of the int2X4 property.
1927: *
1928: * <p>
1929: * This accessor method returns a reference to the live list,
1930: * not a snapshot. Therefore any modification you make to the
1931: * returned list will be present inside the JAXB object.
1932: * This is why there is not a <CODE>set</CODE> method for the int2X4 property.
1933: *
1934: * <p>
1935: * For example, to add a new item, do as follows:
1936: * <pre>
1937: * getInt2X4().add(newItem);
1938: * </pre>
1939: *
1940: *
1941: * <p>
1942: * Objects of the following type(s) are allowed in the list
1943: * {@link Integer }
1944: *
1945: *
1946: */
1947: public List<Integer> getInt2X4() {
1948: if (int2X4 == null) {
1949: int2X4 = new ArrayList<Integer>();
1950: }
1951: return this .int2X4;
1952: }
1953:
1954: /**
1955: * Gets the value of the float2 property.
1956: *
1957: * <p>
1958: * This accessor method returns a reference to the live list,
1959: * not a snapshot. Therefore any modification you make to the
1960: * returned list will be present inside the JAXB object.
1961: * This is why there is not a <CODE>set</CODE> method for the float2 property.
1962: *
1963: * <p>
1964: * For example, to add a new item, do as follows:
1965: * <pre>
1966: * getFloat2().add(newItem);
1967: * </pre>
1968: *
1969: *
1970: * <p>
1971: * Objects of the following type(s) are allowed in the list
1972: * {@link Float }
1973: *
1974: *
1975: */
1976: public List<Float> getFloat2() {
1977: if (float2 == null) {
1978: float2 = new ArrayList<Float>();
1979: }
1980: return this .float2;
1981: }
1982:
1983: /**
1984: * Gets the value of the bool3X4 property.
1985: *
1986: * <p>
1987: * This accessor method returns a reference to the live list,
1988: * not a snapshot. Therefore any modification you make to the
1989: * returned list will be present inside the JAXB object.
1990: * This is why there is not a <CODE>set</CODE> method for the bool3X4 property.
1991: *
1992: * <p>
1993: * For example, to add a new item, do as follows:
1994: * <pre>
1995: * getBool3X4().add(newItem);
1996: * </pre>
1997: *
1998: *
1999: * <p>
2000: * Objects of the following type(s) are allowed in the list
2001: * {@link Boolean }
2002: *
2003: *
2004: */
2005: public List<Boolean> getBool3X4() {
2006: if (bool3X4 == null) {
2007: bool3X4 = new ArrayList<Boolean>();
2008: }
2009: return this .bool3X4;
2010: }
2011:
2012: /**
2013: * Gets the value of the half4X3 property.
2014: *
2015: * <p>
2016: * This accessor method returns a reference to the live list,
2017: * not a snapshot. Therefore any modification you make to the
2018: * returned list will be present inside the JAXB object.
2019: * This is why there is not a <CODE>set</CODE> method for the half4X3 property.
2020: *
2021: * <p>
2022: * For example, to add a new item, do as follows:
2023: * <pre>
2024: * getHalf4X3().add(newItem);
2025: * </pre>
2026: *
2027: *
2028: * <p>
2029: * Objects of the following type(s) are allowed in the list
2030: * {@link Float }
2031: *
2032: *
2033: */
2034: public List<Float> getHalf4X3() {
2035: if (half4X3 == null) {
2036: half4X3 = new ArrayList<Float>();
2037: }
2038: return this .half4X3;
2039: }
2040:
2041: /**
2042: * Gets the value of the float1X3 property.
2043: *
2044: * <p>
2045: * This accessor method returns a reference to the live list,
2046: * not a snapshot. Therefore any modification you make to the
2047: * returned list will be present inside the JAXB object.
2048: * This is why there is not a <CODE>set</CODE> method for the float1X3 property.
2049: *
2050: * <p>
2051: * For example, to add a new item, do as follows:
2052: * <pre>
2053: * getFloat1X3().add(newItem);
2054: * </pre>
2055: *
2056: *
2057: * <p>
2058: * Objects of the following type(s) are allowed in the list
2059: * {@link Float }
2060: *
2061: *
2062: */
2063: public List<Float> getFloat1X3() {
2064: if (float1X3 == null) {
2065: float1X3 = new ArrayList<Float>();
2066: }
2067: return this .float1X3;
2068: }
2069:
2070: /**
2071: * Gets the value of the float4 property.
2072: *
2073: * <p>
2074: * This accessor method returns a reference to the live list,
2075: * not a snapshot. Therefore any modification you make to the
2076: * returned list will be present inside the JAXB object.
2077: * This is why there is not a <CODE>set</CODE> method for the float4 property.
2078: *
2079: * <p>
2080: * For example, to add a new item, do as follows:
2081: * <pre>
2082: * getFloat4().add(newItem);
2083: * </pre>
2084: *
2085: *
2086: * <p>
2087: * Objects of the following type(s) are allowed in the list
2088: * {@link Float }
2089: *
2090: *
2091: */
2092: public List<Float> getFloat4() {
2093: if (float4 == null) {
2094: float4 = new ArrayList<Float>();
2095: }
2096: return this .float4;
2097: }
2098:
2099: /**
2100: * Gets the value of the float2X2 property.
2101: *
2102: * <p>
2103: * This accessor method returns a reference to the live list,
2104: * not a snapshot. Therefore any modification you make to the
2105: * returned list will be present inside the JAXB object.
2106: * This is why there is not a <CODE>set</CODE> method for the float2X2 property.
2107: *
2108: * <p>
2109: * For example, to add a new item, do as follows:
2110: * <pre>
2111: * getFloat2X2().add(newItem);
2112: * </pre>
2113: *
2114: *
2115: * <p>
2116: * Objects of the following type(s) are allowed in the list
2117: * {@link Float }
2118: *
2119: *
2120: */
2121: public List<Float> getFloat2X2() {
2122: if (float2X2 == null) {
2123: float2X2 = new ArrayList<Float>();
2124: }
2125: return this .float2X2;
2126: }
2127:
2128: /**
2129: * Gets the value of the fixed4 property.
2130: *
2131: * <p>
2132: * This accessor method returns a reference to the live list,
2133: * not a snapshot. Therefore any modification you make to the
2134: * returned list will be present inside the JAXB object.
2135: * This is why there is not a <CODE>set</CODE> method for the fixed4 property.
2136: *
2137: * <p>
2138: * For example, to add a new item, do as follows:
2139: * <pre>
2140: * getFixed4().add(newItem);
2141: * </pre>
2142: *
2143: *
2144: * <p>
2145: * Objects of the following type(s) are allowed in the list
2146: * {@link Float }
2147: *
2148: *
2149: */
2150: public List<Float> getFixed4() {
2151: if (fixed4 == null) {
2152: fixed4 = new ArrayList<Float>();
2153: }
2154: return this .fixed4;
2155: }
2156:
2157: /**
2158: * Gets the value of the fixed3X1 property.
2159: *
2160: * <p>
2161: * This accessor method returns a reference to the live list,
2162: * not a snapshot. Therefore any modification you make to the
2163: * returned list will be present inside the JAXB object.
2164: * This is why there is not a <CODE>set</CODE> method for the fixed3X1 property.
2165: *
2166: * <p>
2167: * For example, to add a new item, do as follows:
2168: * <pre>
2169: * getFixed3X1().add(newItem);
2170: * </pre>
2171: *
2172: *
2173: * <p>
2174: * Objects of the following type(s) are allowed in the list
2175: * {@link Float }
2176: *
2177: *
2178: */
2179: public List<Float> getFixed3X1() {
2180: if (fixed3X1 == null) {
2181: fixed3X1 = new ArrayList<Float>();
2182: }
2183: return this .fixed3X1;
2184: }
2185:
2186: /**
2187: * Gets the value of the int2X3 property.
2188: *
2189: * <p>
2190: * This accessor method returns a reference to the live list,
2191: * not a snapshot. Therefore any modification you make to the
2192: * returned list will be present inside the JAXB object.
2193: * This is why there is not a <CODE>set</CODE> method for the int2X3 property.
2194: *
2195: * <p>
2196: * For example, to add a new item, do as follows:
2197: * <pre>
2198: * getInt2X3().add(newItem);
2199: * </pre>
2200: *
2201: *
2202: * <p>
2203: * Objects of the following type(s) are allowed in the list
2204: * {@link Integer }
2205: *
2206: *
2207: */
2208: public List<Integer> getInt2X3() {
2209: if (int2X3 == null) {
2210: int2X3 = new ArrayList<Integer>();
2211: }
2212: return this .int2X3;
2213: }
2214:
2215: /**
2216: * Gets the value of the fixed3X2 property.
2217: *
2218: * <p>
2219: * This accessor method returns a reference to the live list,
2220: * not a snapshot. Therefore any modification you make to the
2221: * returned list will be present inside the JAXB object.
2222: * This is why there is not a <CODE>set</CODE> method for the fixed3X2 property.
2223: *
2224: * <p>
2225: * For example, to add a new item, do as follows:
2226: * <pre>
2227: * getFixed3X2().add(newItem);
2228: * </pre>
2229: *
2230: *
2231: * <p>
2232: * Objects of the following type(s) are allowed in the list
2233: * {@link Float }
2234: *
2235: *
2236: */
2237: public List<Float> getFixed3X2() {
2238: if (fixed3X2 == null) {
2239: fixed3X2 = new ArrayList<Float>();
2240: }
2241: return this .fixed3X2;
2242: }
2243:
2244: /**
2245: * Gets the value of the fixed2X3 property.
2246: *
2247: * <p>
2248: * This accessor method returns a reference to the live list,
2249: * not a snapshot. Therefore any modification you make to the
2250: * returned list will be present inside the JAXB object.
2251: * This is why there is not a <CODE>set</CODE> method for the fixed2X3 property.
2252: *
2253: * <p>
2254: * For example, to add a new item, do as follows:
2255: * <pre>
2256: * getFixed2X3().add(newItem);
2257: * </pre>
2258: *
2259: *
2260: * <p>
2261: * Objects of the following type(s) are allowed in the list
2262: * {@link Float }
2263: *
2264: *
2265: */
2266: public List<Float> getFixed2X3() {
2267: if (fixed2X3 == null) {
2268: fixed2X3 = new ArrayList<Float>();
2269: }
2270: return this .fixed2X3;
2271: }
2272:
2273: /**
2274: * Gets the value of the int2X1 property.
2275: *
2276: * <p>
2277: * This accessor method returns a reference to the live list,
2278: * not a snapshot. Therefore any modification you make to the
2279: * returned list will be present inside the JAXB object.
2280: * This is why there is not a <CODE>set</CODE> method for the int2X1 property.
2281: *
2282: * <p>
2283: * For example, to add a new item, do as follows:
2284: * <pre>
2285: * getInt2X1().add(newItem);
2286: * </pre>
2287: *
2288: *
2289: * <p>
2290: * Objects of the following type(s) are allowed in the list
2291: * {@link Integer }
2292: *
2293: *
2294: */
2295: public List<Integer> getInt2X1() {
2296: if (int2X1 == null) {
2297: int2X1 = new ArrayList<Integer>();
2298: }
2299: return this .int2X1;
2300: }
2301:
2302: /**
2303: * Gets the value of the int1X4 property.
2304: *
2305: * <p>
2306: * This accessor method returns a reference to the live list,
2307: * not a snapshot. Therefore any modification you make to the
2308: * returned list will be present inside the JAXB object.
2309: * This is why there is not a <CODE>set</CODE> method for the int1X4 property.
2310: *
2311: * <p>
2312: * For example, to add a new item, do as follows:
2313: * <pre>
2314: * getInt1X4().add(newItem);
2315: * </pre>
2316: *
2317: *
2318: * <p>
2319: * Objects of the following type(s) are allowed in the list
2320: * {@link Integer }
2321: *
2322: *
2323: */
2324: public List<Integer> getInt1X4() {
2325: if (int1X4 == null) {
2326: int1X4 = new ArrayList<Integer>();
2327: }
2328: return this .int1X4;
2329: }
2330:
2331: /**
2332: * Gets the value of the fixed4X2 property.
2333: *
2334: * <p>
2335: * This accessor method returns a reference to the live list,
2336: * not a snapshot. Therefore any modification you make to the
2337: * returned list will be present inside the JAXB object.
2338: * This is why there is not a <CODE>set</CODE> method for the fixed4X2 property.
2339: *
2340: * <p>
2341: * For example, to add a new item, do as follows:
2342: * <pre>
2343: * getFixed4X2().add(newItem);
2344: * </pre>
2345: *
2346: *
2347: * <p>
2348: * Objects of the following type(s) are allowed in the list
2349: * {@link Float }
2350: *
2351: *
2352: */
2353: public List<Float> getFixed4X2() {
2354: if (fixed4X2 == null) {
2355: fixed4X2 = new ArrayList<Float>();
2356: }
2357: return this .fixed4X2;
2358: }
2359:
2360: /**
2361: * Gets the value of the int1X3 property.
2362: *
2363: * <p>
2364: * This accessor method returns a reference to the live list,
2365: * not a snapshot. Therefore any modification you make to the
2366: * returned list will be present inside the JAXB object.
2367: * This is why there is not a <CODE>set</CODE> method for the int1X3 property.
2368: *
2369: * <p>
2370: * For example, to add a new item, do as follows:
2371: * <pre>
2372: * getInt1X3().add(newItem);
2373: * </pre>
2374: *
2375: *
2376: * <p>
2377: * Objects of the following type(s) are allowed in the list
2378: * {@link Integer }
2379: *
2380: *
2381: */
2382: public List<Integer> getInt1X3() {
2383: if (int1X3 == null) {
2384: int1X3 = new ArrayList<Integer>();
2385: }
2386: return this .int1X3;
2387: }
2388:
2389: /**
2390: * Gets the value of the int1 property.
2391: *
2392: * @return
2393: * possible object is
2394: * {@link Integer }
2395: *
2396: */
2397: public Integer getInt1() {
2398: return int1;
2399: }
2400:
2401: /**
2402: * Sets the value of the int1 property.
2403: *
2404: * @param value
2405: * allowed object is
2406: * {@link Integer }
2407: *
2408: */
2409: public void setInt1(Integer value) {
2410: this .int1 = value;
2411: }
2412:
2413: /**
2414: * Gets the value of the half3 property.
2415: *
2416: * <p>
2417: * This accessor method returns a reference to the live list,
2418: * not a snapshot. Therefore any modification you make to the
2419: * returned list will be present inside the JAXB object.
2420: * This is why there is not a <CODE>set</CODE> method for the half3 property.
2421: *
2422: * <p>
2423: * For example, to add a new item, do as follows:
2424: * <pre>
2425: * getHalf3().add(newItem);
2426: * </pre>
2427: *
2428: *
2429: * <p>
2430: * Objects of the following type(s) are allowed in the list
2431: * {@link Float }
2432: *
2433: *
2434: */
2435: public List<Float> getHalf3() {
2436: if (half3 == null) {
2437: half3 = new ArrayList<Float>();
2438: }
2439: return this .half3;
2440: }
2441:
2442: /**
2443: * Gets the value of the float4X1 property.
2444: *
2445: * <p>
2446: * This accessor method returns a reference to the live list,
2447: * not a snapshot. Therefore any modification you make to the
2448: * returned list will be present inside the JAXB object.
2449: * This is why there is not a <CODE>set</CODE> method for the float4X1 property.
2450: *
2451: * <p>
2452: * For example, to add a new item, do as follows:
2453: * <pre>
2454: * getFloat4X1().add(newItem);
2455: * </pre>
2456: *
2457: *
2458: * <p>
2459: * Objects of the following type(s) are allowed in the list
2460: * {@link Float }
2461: *
2462: *
2463: */
2464: public List<Float> getFloat4X1() {
2465: if (float4X1 == null) {
2466: float4X1 = new ArrayList<Float>();
2467: }
2468: return this .float4X1;
2469: }
2470:
2471: /**
2472: * Gets the value of the int property.
2473: *
2474: * @return
2475: * possible object is
2476: * {@link Integer }
2477: *
2478: */
2479: public Integer getInt() {
2480: return _int;
2481: }
2482:
2483: /**
2484: * Sets the value of the int property.
2485: *
2486: * @param value
2487: * allowed object is
2488: * {@link Integer }
2489: *
2490: */
2491: public void setInt(Integer value) {
2492: this ._int = value;
2493: }
2494:
2495: /**
2496: * Gets the value of the half2X4 property.
2497: *
2498: * <p>
2499: * This accessor method returns a reference to the live list,
2500: * not a snapshot. Therefore any modification you make to the
2501: * returned list will be present inside the JAXB object.
2502: * This is why there is not a <CODE>set</CODE> method for the half2X4 property.
2503: *
2504: * <p>
2505: * For example, to add a new item, do as follows:
2506: * <pre>
2507: * getHalf2X4().add(newItem);
2508: * </pre>
2509: *
2510: *
2511: * <p>
2512: * Objects of the following type(s) are allowed in the list
2513: * {@link Float }
2514: *
2515: *
2516: */
2517: public List<Float> getHalf2X4() {
2518: if (half2X4 == null) {
2519: half2X4 = new ArrayList<Float>();
2520: }
2521: return this .half2X4;
2522: }
2523:
2524: /**
2525: * Gets the value of the half1X1 property.
2526: *
2527: * <p>
2528: * This accessor method returns a reference to the live list,
2529: * not a snapshot. Therefore any modification you make to the
2530: * returned list will be present inside the JAXB object.
2531: * This is why there is not a <CODE>set</CODE> method for the half1X1 property.
2532: *
2533: * <p>
2534: * For example, to add a new item, do as follows:
2535: * <pre>
2536: * getHalf1X1().add(newItem);
2537: * </pre>
2538: *
2539: *
2540: * <p>
2541: * Objects of the following type(s) are allowed in the list
2542: * {@link Float }
2543: *
2544: *
2545: */
2546: public List<Float> getHalf1X1() {
2547: if (half1X1 == null) {
2548: half1X1 = new ArrayList<Float>();
2549: }
2550: return this .half1X1;
2551: }
2552:
2553: /**
2554: * Gets the value of the half3X2 property.
2555: *
2556: * <p>
2557: * This accessor method returns a reference to the live list,
2558: * not a snapshot. Therefore any modification you make to the
2559: * returned list will be present inside the JAXB object.
2560: * This is why there is not a <CODE>set</CODE> method for the half3X2 property.
2561: *
2562: * <p>
2563: * For example, to add a new item, do as follows:
2564: * <pre>
2565: * getHalf3X2().add(newItem);
2566: * </pre>
2567: *
2568: *
2569: * <p>
2570: * Objects of the following type(s) are allowed in the list
2571: * {@link Float }
2572: *
2573: *
2574: */
2575: public List<Float> getHalf3X2() {
2576: if (half3X2 == null) {
2577: half3X2 = new ArrayList<Float>();
2578: }
2579: return this .half3X2;
2580: }
2581:
2582: /**
2583: * Gets the value of the bool3 property.
2584: *
2585: * <p>
2586: * This accessor method returns a reference to the live list,
2587: * not a snapshot. Therefore any modification you make to the
2588: * returned list will be present inside the JAXB object.
2589: * This is why there is not a <CODE>set</CODE> method for the bool3 property.
2590: *
2591: * <p>
2592: * For example, to add a new item, do as follows:
2593: * <pre>
2594: * getBool3().add(newItem);
2595: * </pre>
2596: *
2597: *
2598: * <p>
2599: * Objects of the following type(s) are allowed in the list
2600: * {@link Boolean }
2601: *
2602: *
2603: */
2604: public List<Boolean> getBool3() {
2605: if (bool3 == null) {
2606: bool3 = new ArrayList<Boolean>();
2607: }
2608: return this .bool3;
2609: }
2610:
2611: /**
2612: * Gets the value of the bool1X1 property.
2613: *
2614: * <p>
2615: * This accessor method returns a reference to the live list,
2616: * not a snapshot. Therefore any modification you make to the
2617: * returned list will be present inside the JAXB object.
2618: * This is why there is not a <CODE>set</CODE> method for the bool1X1 property.
2619: *
2620: * <p>
2621: * For example, to add a new item, do as follows:
2622: * <pre>
2623: * getBool1X1().add(newItem);
2624: * </pre>
2625: *
2626: *
2627: * <p>
2628: * Objects of the following type(s) are allowed in the list
2629: * {@link Boolean }
2630: *
2631: *
2632: */
2633: public List<Boolean> getBool1X1() {
2634: if (bool1X1 == null) {
2635: bool1X1 = new ArrayList<Boolean>();
2636: }
2637: return this .bool1X1;
2638: }
2639:
2640: /**
2641: * Gets the value of the float3X2 property.
2642: *
2643: * <p>
2644: * This accessor method returns a reference to the live list,
2645: * not a snapshot. Therefore any modification you make to the
2646: * returned list will be present inside the JAXB object.
2647: * This is why there is not a <CODE>set</CODE> method for the float3X2 property.
2648: *
2649: * <p>
2650: * For example, to add a new item, do as follows:
2651: * <pre>
2652: * getFloat3X2().add(newItem);
2653: * </pre>
2654: *
2655: *
2656: * <p>
2657: * Objects of the following type(s) are allowed in the list
2658: * {@link Float }
2659: *
2660: *
2661: */
2662: public List<Float> getFloat3X2() {
2663: if (float3X2 == null) {
2664: float3X2 = new ArrayList<Float>();
2665: }
2666: return this .float3X2;
2667: }
2668:
2669: /**
2670: * Gets the value of the int1X2 property.
2671: *
2672: * <p>
2673: * This accessor method returns a reference to the live list,
2674: * not a snapshot. Therefore any modification you make to the
2675: * returned list will be present inside the JAXB object.
2676: * This is why there is not a <CODE>set</CODE> method for the int1X2 property.
2677: *
2678: * <p>
2679: * For example, to add a new item, do as follows:
2680: * <pre>
2681: * getInt1X2().add(newItem);
2682: * </pre>
2683: *
2684: *
2685: * <p>
2686: * Objects of the following type(s) are allowed in the list
2687: * {@link Integer }
2688: *
2689: *
2690: */
2691: public List<Integer> getInt1X2() {
2692: if (int1X2 == null) {
2693: int1X2 = new ArrayList<Integer>();
2694: }
2695: return this .int1X2;
2696: }
2697:
2698: /**
2699: * Gets the value of the string property.
2700: *
2701: * @return
2702: * possible object is
2703: * {@link String }
2704: *
2705: */
2706: public String getString() {
2707: return string;
2708: }
2709:
2710: /**
2711: * Sets the value of the string property.
2712: *
2713: * @param value
2714: * allowed object is
2715: * {@link String }
2716: *
2717: */
2718: public void setString(String value) {
2719: this .string = value;
2720: }
2721:
2722: /**
2723: * Gets the value of the bool1X2 property.
2724: *
2725: * <p>
2726: * This accessor method returns a reference to the live list,
2727: * not a snapshot. Therefore any modification you make to the
2728: * returned list will be present inside the JAXB object.
2729: * This is why there is not a <CODE>set</CODE> method for the bool1X2 property.
2730: *
2731: * <p>
2732: * For example, to add a new item, do as follows:
2733: * <pre>
2734: * getBool1X2().add(newItem);
2735: * </pre>
2736: *
2737: *
2738: * <p>
2739: * Objects of the following type(s) are allowed in the list
2740: * {@link Boolean }
2741: *
2742: *
2743: */
2744: public List<Boolean> getBool1X2() {
2745: if (bool1X2 == null) {
2746: bool1X2 = new ArrayList<Boolean>();
2747: }
2748: return this .bool1X2;
2749: }
2750:
2751: /**
2752: * Gets the value of the fixed1X4 property.
2753: *
2754: * <p>
2755: * This accessor method returns a reference to the live list,
2756: * not a snapshot. Therefore any modification you make to the
2757: * returned list will be present inside the JAXB object.
2758: * This is why there is not a <CODE>set</CODE> method for the fixed1X4 property.
2759: *
2760: * <p>
2761: * For example, to add a new item, do as follows:
2762: * <pre>
2763: * getFixed1X4().add(newItem);
2764: * </pre>
2765: *
2766: *
2767: * <p>
2768: * Objects of the following type(s) are allowed in the list
2769: * {@link Float }
2770: *
2771: *
2772: */
2773: public List<Float> getFixed1X4() {
2774: if (fixed1X4 == null) {
2775: fixed1X4 = new ArrayList<Float>();
2776: }
2777: return this .fixed1X4;
2778: }
2779:
2780: /**
2781: * Gets the value of the half4X1 property.
2782: *
2783: * <p>
2784: * This accessor method returns a reference to the live list,
2785: * not a snapshot. Therefore any modification you make to the
2786: * returned list will be present inside the JAXB object.
2787: * This is why there is not a <CODE>set</CODE> method for the half4X1 property.
2788: *
2789: * <p>
2790: * For example, to add a new item, do as follows:
2791: * <pre>
2792: * getHalf4X1().add(newItem);
2793: * </pre>
2794: *
2795: *
2796: * <p>
2797: * Objects of the following type(s) are allowed in the list
2798: * {@link Float }
2799: *
2800: *
2801: */
2802: public List<Float> getHalf4X1() {
2803: if (half4X1 == null) {
2804: half4X1 = new ArrayList<Float>();
2805: }
2806: return this .half4X1;
2807: }
2808:
2809: /**
2810: * Gets the value of the float2X4 property.
2811: *
2812: * <p>
2813: * This accessor method returns a reference to the live list,
2814: * not a snapshot. Therefore any modification you make to the
2815: * returned list will be present inside the JAXB object.
2816: * This is why there is not a <CODE>set</CODE> method for the float2X4 property.
2817: *
2818: * <p>
2819: * For example, to add a new item, do as follows:
2820: * <pre>
2821: * getFloat2X4().add(newItem);
2822: * </pre>
2823: *
2824: *
2825: * <p>
2826: * Objects of the following type(s) are allowed in the list
2827: * {@link Float }
2828: *
2829: *
2830: */
2831: public List<Float> getFloat2X4() {
2832: if (float2X4 == null) {
2833: float2X4 = new ArrayList<Float>();
2834: }
2835: return this .float2X4;
2836: }
2837:
2838: /**
2839: * Gets the value of the int4X4 property.
2840: *
2841: * <p>
2842: * This accessor method returns a reference to the live list,
2843: * not a snapshot. Therefore any modification you make to the
2844: * returned list will be present inside the JAXB object.
2845: * This is why there is not a <CODE>set</CODE> method for the int4X4 property.
2846: *
2847: * <p>
2848: * For example, to add a new item, do as follows:
2849: * <pre>
2850: * getInt4X4().add(newItem);
2851: * </pre>
2852: *
2853: *
2854: * <p>
2855: * Objects of the following type(s) are allowed in the list
2856: * {@link Integer }
2857: *
2858: *
2859: */
2860: public List<Integer> getInt4X4() {
2861: if (int4X4 == null) {
2862: int4X4 = new ArrayList<Integer>();
2863: }
2864: return this .int4X4;
2865: }
2866:
2867: /**
2868: * Gets the value of the half1X3 property.
2869: *
2870: * <p>
2871: * This accessor method returns a reference to the live list,
2872: * not a snapshot. Therefore any modification you make to the
2873: * returned list will be present inside the JAXB object.
2874: * This is why there is not a <CODE>set</CODE> method for the half1X3 property.
2875: *
2876: * <p>
2877: * For example, to add a new item, do as follows:
2878: * <pre>
2879: * getHalf1X3().add(newItem);
2880: * </pre>
2881: *
2882: *
2883: * <p>
2884: * Objects of the following type(s) are allowed in the list
2885: * {@link Float }
2886: *
2887: *
2888: */
2889: public List<Float> getHalf1X3() {
2890: if (half1X3 == null) {
2891: half1X3 = new ArrayList<Float>();
2892: }
2893: return this .half1X3;
2894: }
2895:
2896: /**
2897: * Gets the value of the fixed3X3 property.
2898: *
2899: * <p>
2900: * This accessor method returns a reference to the live list,
2901: * not a snapshot. Therefore any modification you make to the
2902: * returned list will be present inside the JAXB object.
2903: * This is why there is not a <CODE>set</CODE> method for the fixed3X3 property.
2904: *
2905: * <p>
2906: * For example, to add a new item, do as follows:
2907: * <pre>
2908: * getFixed3X3().add(newItem);
2909: * </pre>
2910: *
2911: *
2912: * <p>
2913: * Objects of the following type(s) are allowed in the list
2914: * {@link Float }
2915: *
2916: *
2917: */
2918: public List<Float> getFixed3X3() {
2919: if (fixed3X3 == null) {
2920: fixed3X3 = new ArrayList<Float>();
2921: }
2922: return this .fixed3X3;
2923: }
2924:
2925: /**
2926: * Gets the value of the float4X4 property.
2927: *
2928: * <p>
2929: * This accessor method returns a reference to the live list,
2930: * not a snapshot. Therefore any modification you make to the
2931: * returned list will be present inside the JAXB object.
2932: * This is why there is not a <CODE>set</CODE> method for the float4X4 property.
2933: *
2934: * <p>
2935: * For example, to add a new item, do as follows:
2936: * <pre>
2937: * getFloat4X4().add(newItem);
2938: * </pre>
2939: *
2940: *
2941: * <p>
2942: * Objects of the following type(s) are allowed in the list
2943: * {@link Float }
2944: *
2945: *
2946: */
2947: public List<Float> getFloat4X4() {
2948: if (float4X4 == null) {
2949: float4X4 = new ArrayList<Float>();
2950: }
2951: return this .float4X4;
2952: }
2953:
2954: /**
2955: * Gets the value of the fixed2X1 property.
2956: *
2957: * <p>
2958: * This accessor method returns a reference to the live list,
2959: * not a snapshot. Therefore any modification you make to the
2960: * returned list will be present inside the JAXB object.
2961: * This is why there is not a <CODE>set</CODE> method for the fixed2X1 property.
2962: *
2963: * <p>
2964: * For example, to add a new item, do as follows:
2965: * <pre>
2966: * getFixed2X1().add(newItem);
2967: * </pre>
2968: *
2969: *
2970: * <p>
2971: * Objects of the following type(s) are allowed in the list
2972: * {@link Float }
2973: *
2974: *
2975: */
2976: public List<Float> getFixed2X1() {
2977: if (fixed2X1 == null) {
2978: fixed2X1 = new ArrayList<Float>();
2979: }
2980: return this .fixed2X1;
2981: }
2982:
2983: /**
2984: * Gets the value of the fixed property.
2985: *
2986: * @return
2987: * possible object is
2988: * {@link Float }
2989: *
2990: */
2991: public Float getFixed() {
2992: return fixed;
2993: }
2994:
2995: /**
2996: * Sets the value of the fixed property.
2997: *
2998: * @param value
2999: * allowed object is
3000: * {@link Float }
3001: *
3002: */
3003: public void setFixed(Float value) {
3004: this .fixed = value;
3005: }
3006:
3007: /**
3008: * Gets the value of the bool4X1 property.
3009: *
3010: * <p>
3011: * This accessor method returns a reference to the live list,
3012: * not a snapshot. Therefore any modification you make to the
3013: * returned list will be present inside the JAXB object.
3014: * This is why there is not a <CODE>set</CODE> method for the bool4X1 property.
3015: *
3016: * <p>
3017: * For example, to add a new item, do as follows:
3018: * <pre>
3019: * getBool4X1().add(newItem);
3020: * </pre>
3021: *
3022: *
3023: * <p>
3024: * Objects of the following type(s) are allowed in the list
3025: * {@link Boolean }
3026: *
3027: *
3028: */
3029: public List<Boolean> getBool4X1() {
3030: if (bool4X1 == null) {
3031: bool4X1 = new ArrayList<Boolean>();
3032: }
3033: return this .bool4X1;
3034: }
3035:
3036: /**
3037: * Gets the value of the float4X3 property.
3038: *
3039: * <p>
3040: * This accessor method returns a reference to the live list,
3041: * not a snapshot. Therefore any modification you make to the
3042: * returned list will be present inside the JAXB object.
3043: * This is why there is not a <CODE>set</CODE> method for the float4X3 property.
3044: *
3045: * <p>
3046: * For example, to add a new item, do as follows:
3047: * <pre>
3048: * getFloat4X3().add(newItem);
3049: * </pre>
3050: *
3051: *
3052: * <p>
3053: * Objects of the following type(s) are allowed in the list
3054: * {@link Float }
3055: *
3056: *
3057: */
3058: public List<Float> getFloat4X3() {
3059: if (float4X3 == null) {
3060: float4X3 = new ArrayList<Float>();
3061: }
3062: return this .float4X3;
3063: }
3064:
3065: /**
3066: * Gets the value of the int4X1 property.
3067: *
3068: * <p>
3069: * This accessor method returns a reference to the live list,
3070: * not a snapshot. Therefore any modification you make to the
3071: * returned list will be present inside the JAXB object.
3072: * This is why there is not a <CODE>set</CODE> method for the int4X1 property.
3073: *
3074: * <p>
3075: * For example, to add a new item, do as follows:
3076: * <pre>
3077: * getInt4X1().add(newItem);
3078: * </pre>
3079: *
3080: *
3081: * <p>
3082: * Objects of the following type(s) are allowed in the list
3083: * {@link Integer }
3084: *
3085: *
3086: */
3087: public List<Integer> getInt4X1() {
3088: if (int4X1 == null) {
3089: int4X1 = new ArrayList<Integer>();
3090: }
3091: return this .int4X1;
3092: }
3093:
3094: /**
3095: * Gets the value of the float3X3 property.
3096: *
3097: * <p>
3098: * This accessor method returns a reference to the live list,
3099: * not a snapshot. Therefore any modification you make to the
3100: * returned list will be present inside the JAXB object.
3101: * This is why there is not a <CODE>set</CODE> method for the float3X3 property.
3102: *
3103: * <p>
3104: * For example, to add a new item, do as follows:
3105: * <pre>
3106: * getFloat3X3().add(newItem);
3107: * </pre>
3108: *
3109: *
3110: * <p>
3111: * Objects of the following type(s) are allowed in the list
3112: * {@link Float }
3113: *
3114: *
3115: */
3116: public List<Float> getFloat3X3() {
3117: if (float3X3 == null) {
3118: float3X3 = new ArrayList<Float>();
3119: }
3120: return this .float3X3;
3121: }
3122:
3123: /**
3124: * Gets the value of the bool4X4 property.
3125: *
3126: * <p>
3127: * This accessor method returns a reference to the live list,
3128: * not a snapshot. Therefore any modification you make to the
3129: * returned list will be present inside the JAXB object.
3130: * This is why there is not a <CODE>set</CODE> method for the bool4X4 property.
3131: *
3132: * <p>
3133: * For example, to add a new item, do as follows:
3134: * <pre>
3135: * getBool4X4().add(newItem);
3136: * </pre>
3137: *
3138: *
3139: * <p>
3140: * Objects of the following type(s) are allowed in the list
3141: * {@link Boolean }
3142: *
3143: *
3144: */
3145: public List<Boolean> getBool4X4() {
3146: if (bool4X4 == null) {
3147: bool4X4 = new ArrayList<Boolean>();
3148: }
3149: return this .bool4X4;
3150: }
3151:
3152: /**
3153: * Gets the value of the fixed3X4 property.
3154: *
3155: * <p>
3156: * This accessor method returns a reference to the live list,
3157: * not a snapshot. Therefore any modification you make to the
3158: * returned list will be present inside the JAXB object.
3159: * This is why there is not a <CODE>set</CODE> method for the fixed3X4 property.
3160: *
3161: * <p>
3162: * For example, to add a new item, do as follows:
3163: * <pre>
3164: * getFixed3X4().add(newItem);
3165: * </pre>
3166: *
3167: *
3168: * <p>
3169: * Objects of the following type(s) are allowed in the list
3170: * {@link Float }
3171: *
3172: *
3173: */
3174: public List<Float> getFixed3X4() {
3175: if (fixed3X4 == null) {
3176: fixed3X4 = new ArrayList<Float>();
3177: }
3178: return this .fixed3X4;
3179: }
3180:
3181: /**
3182: * Gets the value of the half2X2 property.
3183: *
3184: * <p>
3185: * This accessor method returns a reference to the live list,
3186: * not a snapshot. Therefore any modification you make to the
3187: * returned list will be present inside the JAXB object.
3188: * This is why there is not a <CODE>set</CODE> method for the half2X2 property.
3189: *
3190: * <p>
3191: * For example, to add a new item, do as follows:
3192: * <pre>
3193: * getHalf2X2().add(newItem);
3194: * </pre>
3195: *
3196: *
3197: * <p>
3198: * Objects of the following type(s) are allowed in the list
3199: * {@link Float }
3200: *
3201: *
3202: */
3203: public List<Float> getHalf2X2() {
3204: if (half2X2 == null) {
3205: half2X2 = new ArrayList<Float>();
3206: }
3207: return this .half2X2;
3208: }
3209:
3210: /**
3211: * Gets the value of the half4X4 property.
3212: *
3213: * <p>
3214: * This accessor method returns a reference to the live list,
3215: * not a snapshot. Therefore any modification you make to the
3216: * returned list will be present inside the JAXB object.
3217: * This is why there is not a <CODE>set</CODE> method for the half4X4 property.
3218: *
3219: * <p>
3220: * For example, to add a new item, do as follows:
3221: * <pre>
3222: * getHalf4X4().add(newItem);
3223: * </pre>
3224: *
3225: *
3226: * <p>
3227: * Objects of the following type(s) are allowed in the list
3228: * {@link Float }
3229: *
3230: *
3231: */
3232: public List<Float> getHalf4X4() {
3233: if (half4X4 == null) {
3234: half4X4 = new ArrayList<Float>();
3235: }
3236: return this .half4X4;
3237: }
3238:
3239: /**
3240: * Gets the value of the half3X1 property.
3241: *
3242: * <p>
3243: * This accessor method returns a reference to the live list,
3244: * not a snapshot. Therefore any modification you make to the
3245: * returned list will be present inside the JAXB object.
3246: * This is why there is not a <CODE>set</CODE> method for the half3X1 property.
3247: *
3248: * <p>
3249: * For example, to add a new item, do as follows:
3250: * <pre>
3251: * getHalf3X1().add(newItem);
3252: * </pre>
3253: *
3254: *
3255: * <p>
3256: * Objects of the following type(s) are allowed in the list
3257: * {@link Float }
3258: *
3259: *
3260: */
3261: public List<Float> getHalf3X1() {
3262: if (half3X1 == null) {
3263: half3X1 = new ArrayList<Float>();
3264: }
3265: return this .half3X1;
3266: }
3267:
3268: /**
3269: * Gets the value of the int3X2 property.
3270: *
3271: * <p>
3272: * This accessor method returns a reference to the live list,
3273: * not a snapshot. Therefore any modification you make to the
3274: * returned list will be present inside the JAXB object.
3275: * This is why there is not a <CODE>set</CODE> method for the int3X2 property.
3276: *
3277: * <p>
3278: * For example, to add a new item, do as follows:
3279: * <pre>
3280: * getInt3X2().add(newItem);
3281: * </pre>
3282: *
3283: *
3284: * <p>
3285: * Objects of the following type(s) are allowed in the list
3286: * {@link Integer }
3287: *
3288: *
3289: */
3290: public List<Integer> getInt3X2() {
3291: if (int3X2 == null) {
3292: int3X2 = new ArrayList<Integer>();
3293: }
3294: return this .int3X2;
3295: }
3296:
3297: /**
3298: * Gets the value of the int2 property.
3299: *
3300: * <p>
3301: * This accessor method returns a reference to the live list,
3302: * not a snapshot. Therefore any modification you make to the
3303: * returned list will be present inside the JAXB object.
3304: * This is why there is not a <CODE>set</CODE> method for the int2 property.
3305: *
3306: * <p>
3307: * For example, to add a new item, do as follows:
3308: * <pre>
3309: * getInt2().add(newItem);
3310: * </pre>
3311: *
3312: *
3313: * <p>
3314: * Objects of the following type(s) are allowed in the list
3315: * {@link Integer }
3316: *
3317: *
3318: */
3319: public List<Integer> getInt2() {
3320: if (int2 == null) {
3321: int2 = new ArrayList<Integer>();
3322: }
3323: return this .int2;
3324: }
3325:
3326: /**
3327: * Gets the value of the float2X1 property.
3328: *
3329: * <p>
3330: * This accessor method returns a reference to the live list,
3331: * not a snapshot. Therefore any modification you make to the
3332: * returned list will be present inside the JAXB object.
3333: * This is why there is not a <CODE>set</CODE> method for the float2X1 property.
3334: *
3335: * <p>
3336: * For example, to add a new item, do as follows:
3337: * <pre>
3338: * getFloat2X1().add(newItem);
3339: * </pre>
3340: *
3341: *
3342: * <p>
3343: * Objects of the following type(s) are allowed in the list
3344: * {@link Float }
3345: *
3346: *
3347: */
3348: public List<Float> getFloat2X1() {
3349: if (float2X1 == null) {
3350: float2X1 = new ArrayList<Float>();
3351: }
3352: return this .float2X1;
3353: }
3354:
3355: /**
3356: * Gets the value of the half4X2 property.
3357: *
3358: * <p>
3359: * This accessor method returns a reference to the live list,
3360: * not a snapshot. Therefore any modification you make to the
3361: * returned list will be present inside the JAXB object.
3362: * This is why there is not a <CODE>set</CODE> method for the half4X2 property.
3363: *
3364: * <p>
3365: * For example, to add a new item, do as follows:
3366: * <pre>
3367: * getHalf4X2().add(newItem);
3368: * </pre>
3369: *
3370: *
3371: * <p>
3372: * Objects of the following type(s) are allowed in the list
3373: * {@link Float }
3374: *
3375: *
3376: */
3377: public List<Float> getHalf4X2() {
3378: if (half4X2 == null) {
3379: half4X2 = new ArrayList<Float>();
3380: }
3381: return this .half4X2;
3382: }
3383:
3384: /**
3385: * Gets the value of the half3X4 property.
3386: *
3387: * <p>
3388: * This accessor method returns a reference to the live list,
3389: * not a snapshot. Therefore any modification you make to the
3390: * returned list will be present inside the JAXB object.
3391: * This is why there is not a <CODE>set</CODE> method for the half3X4 property.
3392: *
3393: * <p>
3394: * For example, to add a new item, do as follows:
3395: * <pre>
3396: * getHalf3X4().add(newItem);
3397: * </pre>
3398: *
3399: *
3400: * <p>
3401: * Objects of the following type(s) are allowed in the list
3402: * {@link Float }
3403: *
3404: *
3405: */
3406: public List<Float> getHalf3X4() {
3407: if (half3X4 == null) {
3408: half3X4 = new ArrayList<Float>();
3409: }
3410: return this .half3X4;
3411: }
3412:
3413: /**
3414: * Gets the value of the half property.
3415: *
3416: * @return
3417: * possible object is
3418: * {@link Float }
3419: *
3420: */
3421: public Float getHalf() {
3422: return half;
3423: }
3424:
3425: /**
3426: * Sets the value of the half property.
3427: *
3428: * @param value
3429: * allowed object is
3430: * {@link Float }
3431: *
3432: */
3433: public void setHalf(Float value) {
3434: this .half = value;
3435: }
3436:
3437: /**
3438: * Gets the value of the fixed4X4 property.
3439: *
3440: * <p>
3441: * This accessor method returns a reference to the live list,
3442: * not a snapshot. Therefore any modification you make to the
3443: * returned list will be present inside the JAXB object.
3444: * This is why there is not a <CODE>set</CODE> method for the fixed4X4 property.
3445: *
3446: * <p>
3447: * For example, to add a new item, do as follows:
3448: * <pre>
3449: * getFixed4X4().add(newItem);
3450: * </pre>
3451: *
3452: *
3453: * <p>
3454: * Objects of the following type(s) are allowed in the list
3455: * {@link Float }
3456: *
3457: *
3458: */
3459: public List<Float> getFixed4X4() {
3460: if (fixed4X4 == null) {
3461: fixed4X4 = new ArrayList<Float>();
3462: }
3463: return this .fixed4X4;
3464: }
3465:
3466: /**
3467: * Gets the value of the bool3X2 property.
3468: *
3469: * <p>
3470: * This accessor method returns a reference to the live list,
3471: * not a snapshot. Therefore any modification you make to the
3472: * returned list will be present inside the JAXB object.
3473: * This is why there is not a <CODE>set</CODE> method for the bool3X2 property.
3474: *
3475: * <p>
3476: * For example, to add a new item, do as follows:
3477: * <pre>
3478: * getBool3X2().add(newItem);
3479: * </pre>
3480: *
3481: *
3482: * <p>
3483: * Objects of the following type(s) are allowed in the list
3484: * {@link Boolean }
3485: *
3486: *
3487: */
3488: public List<Boolean> getBool3X2() {
3489: if (bool3X2 == null) {
3490: bool3X2 = new ArrayList<Boolean>();
3491: }
3492: return this .bool3X2;
3493: }
3494:
3495: /**
3496: * Gets the value of the float3 property.
3497: *
3498: * <p>
3499: * This accessor method returns a reference to the live list,
3500: * not a snapshot. Therefore any modification you make to the
3501: * returned list will be present inside the JAXB object.
3502: * This is why there is not a <CODE>set</CODE> method for the float3 property.
3503: *
3504: * <p>
3505: * For example, to add a new item, do as follows:
3506: * <pre>
3507: * getFloat3().add(newItem);
3508: * </pre>
3509: *
3510: *
3511: * <p>
3512: * Objects of the following type(s) are allowed in the list
3513: * {@link Float }
3514: *
3515: *
3516: */
3517: public List<Float> getFloat3() {
3518: if (float3 == null) {
3519: float3 = new ArrayList<Float>();
3520: }
3521: return this .float3;
3522: }
3523:
3524: /**
3525: * Gets the value of the bool4X3 property.
3526: *
3527: * <p>
3528: * This accessor method returns a reference to the live list,
3529: * not a snapshot. Therefore any modification you make to the
3530: * returned list will be present inside the JAXB object.
3531: * This is why there is not a <CODE>set</CODE> method for the bool4X3 property.
3532: *
3533: * <p>
3534: * For example, to add a new item, do as follows:
3535: * <pre>
3536: * getBool4X3().add(newItem);
3537: * </pre>
3538: *
3539: *
3540: * <p>
3541: * Objects of the following type(s) are allowed in the list
3542: * {@link Boolean }
3543: *
3544: *
3545: */
3546: public List<Boolean> getBool4X3() {
3547: if (bool4X3 == null) {
3548: bool4X3 = new ArrayList<Boolean>();
3549: }
3550: return this .bool4X3;
3551: }
3552:
3553: /**
3554: * Gets the value of the array property.
3555: *
3556: * @return
3557: * possible object is
3558: * {@link CgSetarrayType }
3559: *
3560: */
3561: public CgSetarrayType getArray() {
3562: return array;
3563: }
3564:
3565: /**
3566: * Sets the value of the array property.
3567: *
3568: * @param value
3569: * allowed object is
3570: * {@link CgSetarrayType }
3571: *
3572: */
3573: public void setArray(CgSetarrayType value) {
3574: this .array = value;
3575: }
3576:
3577: /**
3578: * Gets the value of the fixed1X2 property.
3579: *
3580: * <p>
3581: * This accessor method returns a reference to the live list,
3582: * not a snapshot. Therefore any modification you make to the
3583: * returned list will be present inside the JAXB object.
3584: * This is why there is not a <CODE>set</CODE> method for the fixed1X2 property.
3585: *
3586: * <p>
3587: * For example, to add a new item, do as follows:
3588: * <pre>
3589: * getFixed1X2().add(newItem);
3590: * </pre>
3591: *
3592: *
3593: * <p>
3594: * Objects of the following type(s) are allowed in the list
3595: * {@link Float }
3596: *
3597: *
3598: */
3599: public List<Float> getFixed1X2() {
3600: if (fixed1X2 == null) {
3601: fixed1X2 = new ArrayList<Float>();
3602: }
3603: return this .fixed1X2;
3604: }
3605:
3606: /**
3607: * Gets the value of the sampler2D property.
3608: *
3609: * @return
3610: * possible object is
3611: * {@link CgSampler2D }
3612: *
3613: */
3614: public CgSampler2D getSampler2D() {
3615: return sampler2D;
3616: }
3617:
3618: /**
3619: * Sets the value of the sampler2D property.
3620: *
3621: * @param value
3622: * allowed object is
3623: * {@link CgSampler2D }
3624: *
3625: */
3626: public void setSampler2D(CgSampler2D value) {
3627: this .sampler2D = value;
3628: }
3629:
3630: /**
3631: * Gets the value of the float property.
3632: *
3633: * @return
3634: * possible object is
3635: * {@link Float }
3636: *
3637: */
3638: public Float getFloat() {
3639: return _float;
3640: }
3641:
3642: /**
3643: * Sets the value of the float property.
3644: *
3645: * @param value
3646: * allowed object is
3647: * {@link Float }
3648: *
3649: */
3650: public void setFloat(Float value) {
3651: this ._float = value;
3652: }
3653:
3654: /**
3655: * Gets the value of the program property.
3656: *
3657: * @return
3658: * possible object is
3659: * {@link String }
3660: *
3661: */
3662: public String getProgram() {
3663: return program;
3664: }
3665:
3666: /**
3667: * Sets the value of the program property.
3668: *
3669: * @param value
3670: * allowed object is
3671: * {@link String }
3672: *
3673: */
3674: public void setProgram(String value) {
3675: this .program = value;
3676: }
3677:
3678: /**
3679: * Gets the value of the ref property.
3680: *
3681: * @return
3682: * possible object is
3683: * {@link String }
3684: *
3685: */
3686: public String getRef() {
3687: return ref;
3688: }
3689:
3690: /**
3691: * Sets the value of the ref property.
3692: *
3693: * @param value
3694: * allowed object is
3695: * {@link String }
3696: *
3697: */
3698: public void setRef(String value) {
3699: this.ref = value;
3700: }
3701:
3702: }
|