public  void deleteParamList() 
{
        _ParamList = null;
        invalidate();
}

 public  void emptyParamList() 
{
        _ParamList = PredicatedLists.createInvalidating(this, pred_ParamList,
                new ArrayList());
}

 public boolean equals(Object ob) 
{
        if (this == ob) {
            return true;
        }
        if (!(ob instanceof Error)) {
            return false;
        }
        Error tob = ((Error) ob);
        if (_ParamList != null) {
            if (tob._ParamList == null) {
                return false;
            }
            if (!_ParamList.equals(tob._ParamList)) {
                return false;
            }
        } else {
            if (tob._ParamList != null) {
                return false;
            }
        }
        if (_Exception != null) {
            if (tob._Exception == null) {
                return false;
            }
            if (!_Exception.equals(tob._Exception)) {
                return false;
            }
        } else {
            if (tob._Exception != null) {
                return false;
            }
        }
        if (_Message != null) {
            if (tob._Message == null) {
                return false;
            }
            if (!_Message.equals(tob._Message)) {
                return false;
            }
        } else {
            if (tob._Message != null) {
                return false;
            }
        }
        return true;
}

 public Exception getException() 
{
        return _Exception;
}

 public String getMessage() 
{
        return _Message;
}

 public List getParamList() 
{
       
        return _ParamList;
}

 public int hashCode() 
{
        int h = 0;
        h = ((127 * h) + ((_ParamList != null) ? _ParamList.hashCode() : 0));
        h = ((127 * h) + ((_Exception != null) ? _Exception.hashCode() : 0));
        h = ((127 * h) + ((_Message != null) ? _Message.hashCode() : 0));
        return h;
}

 public  void marshal(Marshaller m) throws IOException 
{
        XMLWriter w = m.writer();
        w.start("error");
        w.attribute("exception", ExceptionConverter.print(_Exception));
        if (_Message != null) {
            w.attribute("message", _Message.toString());
        }
        for (Iterator i = _ParamList.iterator(); i.hasNext();) {
            m.marshal(((MarshallableObject) i.next()));
        }
        w.end("error");
}

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

 public  void setException(Exception _Exception) 
{
        this._Exception = _Exception;
        if (_Exception == null) {
            invalidate();
        }
}

 public  void setMessage(String _Message) 
{
        this._Message = _Message;
        if (_Message == null) {
            invalidate();
        }
}

 public String toString() 
{
        StringBuffer sb = new StringBuffer("< < error");
        if (_ParamList != null) {
            sb.append(" paramList=");
            sb.append(_ParamList.toString());
        }
        if (_Exception != null) {
            sb.append(" exception=");
            sb.append(ExceptionConverter.print(_Exception));
        }
        if (_Message != null) {
            sb.append(" message=");
            sb.append(_Message.toString());
        }
        sb.append(" > >");
        return sb.toString();
}

 public  void unmarshal(Unmarshaller u) throws UnmarshalException 
{
        XMLScanner xs = u.scanner();
        Validator v = u.validator();
        xs.takeStart("error");
        while (xs.atAttribute()) {
            String an = xs.takeAttributeName();
            if (an.equals("exception")) {
                if (_Exception != null) {
                    throw new DuplicateAttributeException(an);
                }
                try {
                    _Exception = ExceptionConverter.parse(xs.takeAttributeValue());
                } catch (Exception x) {
                    throw new ConversionException(an, x);
                }
                continue;
            }
            if (an.equals("message")) {
                if (_Message != null) {
                    throw new DuplicateAttributeException(an);
                }
                _Message = xs.takeAttributeValue();
                continue;
            }
            throw new InvalidAttributeException(an);
        }
        {
            List l = PredicatedLists.create(this, pred_ParamList,
                    new ArrayList());
            while (xs.atStart("stackTrace") || xs.atStart("param")) {
                l.add(((MarshallableObject) u.unmarshal()));
            }
            _ParamList = PredicatedLists.createInvalidating(this,
                    pred_ParamList, l);
        }
        xs.takeEnd("error");
}

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

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

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

 public  void validate(Validator v) throws StructureValidationException 
{
        for (Iterator i = _ParamList.iterator(); i.hasNext();) {
            v.validate(((ValidatableObject) i.next()));
        }
}

 public  void validateThis() throws LocalValidationException 
{
        if (_ParamList == null) {
            throw new MissingContentException("paramList");
        }
        if (_Exception == null) {
            throw new MissingAttributeException("exception");
        }
}