public  void deletePropertyList() 
{
        _PropertyList = null;
        invalidate();
}

 public  void emptyPropertyList() 
{
        _PropertyList = PredicatedLists.createInvalidating(this,
                pred_PropertyList, new ArrayList());
}

 public boolean equals(Object ob) 
{
        if (this == ob) {
            return true;
        }
        if (!(ob instanceof Runtime)) {
            return false;
        }
        Runtime tob = ((Runtime) ob);
        if (_CommandLine != null) {
            if (tob._CommandLine == null) {
                return false;
            }
            if (!_CommandLine.equals(tob._CommandLine)) {
                return false;
            }
        } else {
            if (tob._CommandLine != null) {
                return false;
            }
        }
        if (_ClassPath != null) {
            if (tob._ClassPath == null) {
                return false;
            }
            if (!_ClassPath.equals(tob._ClassPath)) {
                return false;
            }
        } else {
            if (tob._ClassPath != null) {
                return false;
            }
        }
        if (_JavaOptions != null) {
            if (tob._JavaOptions == null) {
                return false;
            }
            if (!_JavaOptions.equals(tob._JavaOptions)) {
                return false;
            }
        } else {
            if (tob._JavaOptions != null) {
                return false;
            }
        }
        if (_PropertyList != null) {
            if (tob._PropertyList == null) {
                return false;
            }
            if (!_PropertyList.equals(tob._PropertyList)) {
                return false;
            }
        } else {
            if (tob._PropertyList != null) {
                return false;
            }
        }
        return true;
}

 public ClassPath getClassPath() 
{
        return _ClassPath;
}

 public CommandLine getCommandLine() 
{
       
        return _CommandLine;
}

 public JavaOptions getJavaOptions() 
{
        return _JavaOptions;
}

 public List getPropertyList() 
{
        return _PropertyList;
}

 public int hashCode() 
{
        int h = 0;
        h = ((127 * h) +
            ((_CommandLine != null) ? _CommandLine.hashCode() : 0));
        h = ((127 * h) + ((_ClassPath != null) ? _ClassPath.hashCode() : 0));
        h = ((127 * h) +
            ((_JavaOptions != null) ? _JavaOptions.hashCode() : 0));
        h = ((127 * h) +
            ((_PropertyList != null) ? _PropertyList.hashCode() : 0));
        return h;
}

 public  void marshal(Marshaller m) throws IOException 
{
        XMLWriter w = m.writer();
        w.start("runtime");
        if (_CommandLine != null) {
            m.marshal(_CommandLine);
        }
        if (_ClassPath != null) {
            m.marshal(_ClassPath);
        }
        if (_JavaOptions != null) {
            m.marshal(_JavaOptions);
        }
        if (_PropertyList.size()  > 0) {
            for (Iterator i = _PropertyList.iterator(); i.hasNext();) {
                m.marshal(((MarshallableObject) i.next()));
            }
        }
        w.end("runtime");
}

 public static Dispatcher newDispatcher() 
{
        return Author.newDispatcher();
}

 public  void setClassPath(ClassPath _ClassPath) 
{
        this._ClassPath = _ClassPath;
        if (_ClassPath == null) {
            invalidate();
        }
}

 public  void setCommandLine(CommandLine _CommandLine) 
{
        this._CommandLine = _CommandLine;
        if (_CommandLine == null) {
            invalidate();
        }
}

 public  void setJavaOptions(JavaOptions _JavaOptions) 
{
        this._JavaOptions = _JavaOptions;
        if (_JavaOptions == null) {
            invalidate();
        }
}

 public String toString() 
{
        StringBuffer sb = new StringBuffer("< < runtime");
        if (_CommandLine != null) {
            sb.append(" commandLine=");
            sb.append(_CommandLine.toString());
        }
        if (_ClassPath != null) {
            sb.append(" classPath=");
            sb.append(_ClassPath.toString());
        }
        if (_JavaOptions != null) {
            sb.append(" javaOptions=");
            sb.append(_JavaOptions.toString());
        }
        if (_PropertyList != null) {
            sb.append(" property=");
            sb.append(_PropertyList.toString());
        }
        sb.append(" > >");
        return sb.toString();
}

 public  void unmarshal(Unmarshaller u) throws UnmarshalException 
{
        XMLScanner xs = u.scanner();
        Validator v = u.validator();
        xs.takeStart("runtime");
        while (xs.atAttribute()) {
            String an = xs.takeAttributeName();
            throw new InvalidAttributeException(an);
        }
        if (xs.atStart("commandLine")) {
            _CommandLine = ((CommandLine) u.unmarshal());
        }
        if (xs.atStart("classPath")) {
            _ClassPath = ((ClassPath) u.unmarshal());
        }
        if (xs.atStart("javaOptions")) {
            _JavaOptions = ((JavaOptions) u.unmarshal());
        }
        {
            List l = PredicatedLists.create(this, pred_PropertyList,
                    new ArrayList());
            while (xs.atStart("property")) {
                l.add(((Property) u.unmarshal()));
            }
            _PropertyList = PredicatedLists.createInvalidating(this,
                    pred_PropertyList, l);
        }
        xs.takeEnd("runtime");
}

 public static Runtime unmarshal(InputStream in) throws UnmarshalException 
{
        return unmarshal(XMLScanner.open(in));
}

 public static Runtime unmarshal(XMLScanner xs) throws UnmarshalException 
{
        return unmarshal(xs, newDispatcher());
}

 public static Runtime unmarshal(XMLScanner xs,
    Dispatcher d) throws UnmarshalException 
{
        return ((Runtime) d.unmarshal(xs, (Runtime.class)));
}

 public  void validate(Validator v) throws StructureValidationException 
{
        if (_CommandLine != null) {
            v.validate(_CommandLine);
        }
        if (_ClassPath != null) {
            v.validate(_ClassPath);
        }
        if (_JavaOptions != null) {
            v.validate(_JavaOptions);
        }
        for (Iterator i = _PropertyList.iterator(); i.hasNext();) {
            v.validate(((ValidatableObject) i.next()));
        }
}

JAXB 1.0 EA bug fix for handling optional elements

 public  void validateThis() throws LocalValidationException 
{

}