messageoptionimpl.java

java写的qq代码实现qq的部分功能

/**
 * This class was generated from a set of XML constraints
 *   by the Enhydra Zeus XML Data Binding Framework. All
 *   source code in this file is constructed specifically
 *   to work with other Zeus-generated classes. If you
 *   modify this file by hand, you run the risk of breaking
 *   this interoperation, as well as introducing errors in
 *   source code compilation.
 *
 * * * * * MODIFY THIS FILE AT YOUR OWN RISK * * * * *
 *
 * To find out more about the Enhydra Zeus framework, you
 *   can point your browser at <http://zeus.enhydra.org>
 *   where you can download releases, join and discuss Zeus
 *   on user and developer mailing lists, and access source
 *   code. Please report any bugs through that website.
 */
package edu.tsinghua.lumaqq.xml.sysopts;

// Global Implementation Import Statements
import java.io.*;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import org.xml.sax.EntityResolver;
import org.xml.sax.ErrorHandler;
import org.xml.sax.InputSource;
import org.xml.sax.Locator;
import org.xml.sax.SAXException;
import org.xml.sax.SAXParseException;
import org.xml.sax.XMLReader;
import org.xml.sax.ext.LexicalHandler;
import org.xml.sax.helpers.DefaultHandler;
import org.xml.sax.helpers.XMLReaderFactory;

public class MessageOptionImpl extends DefaultHandler implements Cloneable, Unmarshallable, LexicalHandler, MessageOption {

    private String autoEject;
    private static boolean zeus_AutoEjectInitialized;
    private static java.util.Vector zeus_validAutoEject;
    private boolean zeus_AutoEjectSet;
    private String enableSound;
    private static boolean zeus_EnableSoundInitialized;
    private static java.util.Vector zeus_validEnableSound;
    private boolean zeus_EnableSoundSet;
    private String useEnterInTalkMode;
    private static boolean zeus_UseEnterInTalkModeInitialized;
    private static java.util.Vector zeus_validUseEnterInTalkMode;
    private boolean zeus_UseEnterInTalkModeSet;
    private String useEnterInMessageMode;
    private static boolean zeus_UseEnterInMessageModeInitialized;
    private static java.util.Vector zeus_validUseEnterInMessageMode;
    private boolean zeus_UseEnterInMessageModeSet;
    private String rejectStranger;
    private static boolean zeus_RejectStrangerInitialized;
    private static java.util.Vector zeus_validRejectStranger;
    private boolean zeus_RejectStrangerSet;

    /** Any DOCTYPE reference/statements. */
    private String docTypeString;

    /** The encoding for the output document */
    private String outputEncoding;

    /** The current node in unmarshalling */
    private Unmarshallable zeus_currentUNode;

    /** The parent node in unmarshalling */
    private Unmarshallable zeus_parentUNode;

    /** Whether this node has been handled */
    private boolean zeus_thisNodeHandled = false;

    /** Whether a DTD exists for an unmarshal call */
    private boolean hasDTD;

    /** Whether validation is occurring */
    private boolean validate;

    /** The namespace mappings on this element */
    private Map namespaceMappings;

    /** The EntityResolver for SAX parsing to use */
    private static EntityResolver entityResolver;

    /** The ErrorHandler for SAX parsing to use */
    private static ErrorHandler errorHandler;

    private static MessageOptionImpl prototype = null;

    public static void setPrototype(MessageOptionImpl prototype) {
        MessageOptionImpl.prototype = prototype;
    }
    public static MessageOptionImpl newInstance() {
        try {
            return (prototype!=null)?(MessageOptionImpl)prototype.clone(): new MessageOptionImpl();
        } catch (CloneNotSupportedException e) {
            return null; // never
        }
    }
    public MessageOptionImpl() {
        zeus_AutoEjectInitialized = false;
        zeus_validAutoEject = null;
        zeus_AutoEjectSet = false;
        zeus_EnableSoundInitialized = false;
        zeus_validEnableSound = null;
        zeus_EnableSoundSet = false;
        zeus_UseEnterInTalkModeInitialized = false;
        zeus_validUseEnterInTalkMode = null;
        zeus_UseEnterInTalkModeSet = false;
        zeus_UseEnterInMessageModeInitialized = false;
        zeus_validUseEnterInMessageMode = null;
        zeus_UseEnterInMessageModeSet = false;
        zeus_RejectStrangerInitialized = false;
        zeus_validRejectStranger = null;
        zeus_RejectStrangerSet = false;
        docTypeString = "";
        hasDTD = false;
        validate = false;
        namespaceMappings = new HashMap();
    }

    public String getAutoEject() {
        if(autoEject == null) 
            return "";
        else
            return autoEject;
    }

    public void setAutoEject(String autoEject)
        throws IllegalArgumentException {
        if (!zeus_AutoEjectInitialized) {
            zeus_validAutoEject = new java.util.Vector();
            zeus_validAutoEject.addElement("true");
            zeus_validAutoEject.addElement("false");
            zeus_AutoEjectInitialized = true;
        }
        if (!zeus_validAutoEject.contains(autoEject)) {
              throw new IllegalArgumentException("Illegal value for attribute 'autoEject'");
        } else {
              this.autoEject = autoEject;
            this.zeus_AutoEjectSet = true;
        }
    }

    public String getEnableSound() {
        if(enableSound == null) 
            return "";
        else
            return enableSound;
    }

    public void setEnableSound(String enableSound)
        throws IllegalArgumentException {
        if (!zeus_EnableSoundInitialized) {
            zeus_validEnableSound = new java.util.Vector();
            zeus_validEnableSound.addElement("true");
            zeus_validEnableSound.addElement("false");
            zeus_EnableSoundInitialized = true;
        }
        if (!zeus_validEnableSound.contains(enableSound)) {
              throw new IllegalArgumentException("Illegal value for attribute 'enableSound'");
        } else {
              this.enableSound = enableSound;
            this.zeus_EnableSoundSet = true;
        }
    }

    public String getUseEnterInTalkMode() {
        if(useEnterInTalkMode == null) 
            return "";
        else
            return useEnterInTalkMode;
    }

    public void setUseEnterInTalkMode(String useEnterInTalkMode)
        throws IllegalArgumentException {
        if (!zeus_UseEnterInTalkModeInitialized) {
            zeus_validUseEnterInTalkMode = new java.util.Vector();
            zeus_validUseEnterInTalkMode.addElement("true");
            zeus_validUseEnterInTalkMode.addElement("false");
            zeus_UseEnterInTalkModeInitialized = true;
        }
        if (!zeus_validUseEnterInTalkMode.contains(useEnterInTalkMode)) {
              throw new IllegalArgumentException("Illegal value for attribute 'useEnterInTalkMode'");
        } else {
              this.useEnterInTalkMode = useEnterInTalkMode;
            this.zeus_UseEnterInTalkModeSet = true;
        }
    }

    public String getUseEnterInMessageMode() {
        if(useEnterInMessageMode == null) 
            return "";
        else
            return useEnterInMessageMode;
    }

    public void setUseEnterInMessageMode(String useEnterInMessageMode)
        throws IllegalArgumentException {
        if (!zeus_UseEnterInMessageModeInitialized) {
            zeus_validUseEnterInMessageMode = new java.util.Vector();
            zeus_validUseEnterInMessageMode.addElement("true");
            zeus_validUseEnterInMessageMode.addElement("false");
            zeus_UseEnterInMessageModeInitialized = true;
        }
        if (!zeus_validUseEnterInMessageMode.contains(useEnterInMessageMode)) {
              throw new IllegalArgumentException("Illegal value for attribute 'useEnterInMessageMode'");
        } else {
              this.useEnterInMessageMode = useEnterInMessageMode;
            this.zeus_UseEnterInMessageModeSet = true;
        }
    }

    public String getRejectStranger() {
        if(rejectStranger == null) 
            return "";
        else
            return rejectStranger;
    }

    public void setRejectStranger(String rejectStranger)
        throws IllegalArgumentException {
        if (!zeus_RejectStrangerInitialized) {
            zeus_validRejectStranger = new java.util.Vector();
            zeus_validRejectStranger.addElement("true");
            zeus_validRejectStranger.addElement("false");
            zeus_RejectStrangerInitialized = true;
        }
        if (!zeus_validRejectStranger.contains(rejectStranger)) {
              throw new IllegalArgumentException("Illegal value for attribute 'rejectStranger'");
        } else {
              this.rejectStranger = rejectStranger;
            this.zeus_RejectStrangerSet = true;
        }
    }

    public void setDocType(String name, String publicID, String systemID) {
        try {
            startDTD(name, publicID, systemID);
        } catch (SAXException neverHappens) { }
    }

    public void setOutputEncoding(String outputEncoding) {
        this.outputEncoding = outputEncoding;
    }

    public void marshal(File file) throws IOException {
        // Delegate to the marshal(Writer) method
        if (outputEncoding != null) {
                marshal(new OutputStreamWriter(new FileOutputStream(file), outputEncoding));
        } else {
                marshal(new OutputStreamWriter(new FileOutputStream(file), "utf-8"));
        }
    }

    public void marshal(OutputStream outputStream) throws IOException {
        // Delegate to the marshal(Writer) method
        if (outputEncoding != null) {
                marshal(new OutputStreamWriter(outputStream, outputEncoding));
        } else {
                marshal(new OutputStreamWriter(outputStream, "utf-8"));
        }
    }

    public void marshal(Writer writer) throws IOException {
        // Write out the XML declaration
        writer.write("<?xml version=\"1.0\" ");
        if (outputEncoding != null) {
            writer.write("encoding=\"");
            writer.write(outputEncoding);
            writer.write("\"?>\n\n");

        } else {
            writer.write("encoding=\"UTF-8\"?>\n\n");

        }
        // Handle DOCTYPE declaration
        writer.write(docTypeString);
        writer.write("\n");
        // Now start the recursive writing
        writeXMLRepresentation(writer, "");

        // Close up
        writer.flush();
        writer.close();
    }

    protected void writeXMLRepresentation(Writer writer,
                                          String indent)
        throws IOException {

        writer.write(indent);
        writer.write("<MessageOption");

        // Handle namespace mappings (if needed)
        for (Iterator i = namespaceMappings.keySet().iterator(); i.hasNext(); ) {
            String prefix = (String)i.next();
            String uri = (String)namespaceMappings.get(prefix);
            writer.write(" xmlns");
            if (!prefix.trim().equals("")) {
                writer.write(":");
                writer.write(prefix);
            }
            writer.write("=\"");
            writer.write(uri);
            writer.write("\"\n        ");
        }

        // Handle attributes (if needed)
        if (zeus_AutoEjectSet) {
            writer.write(" autoEject=\"");
            writer.write(escapeAttributeValue(autoEject));
            writer.write("\"");
        }
        if (zeus_EnableSoundSet) {
            writer.write(" enableSound=\"");
            writer.write(escapeAttributeValue(enableSound));
            writer.write("\"");
        }
        if (zeus_UseEnterInTalkModeSet) {
            writer.write(" useEnterInTalkMode=\"");
            writer.write(escapeAttributeValue(useEnterInTalkMode));
            writer.write("\"");
        }
        if (zeus_UseEnterInMessageModeSet) {
            writer.write(" useEnterInMessageMode=\"");
            writer.write(escapeAttributeValue(useEnterInMessageMode));
            writer.write("\"");
        }
        if (zeus_RejectStrangerSet) {
            writer.write(" rejectStranger=\"");
            writer.write(escapeAttributeValue(rejectStranger));
            writer.write("\"");
        }
        writer.write("/>\n");
    }

    private String escapeAttributeValue(String attributeValue) {
        String returnValue = attributeValue;
        for (int i = 0; i < returnValue.length(); i++) {
            char ch = returnValue.charAt(i);
            if (ch < 0x20) {
                if ( (ch != 0x09) && (ch != 0x0a) && (ch != 0x0d) ) {
                    returnValue = new StringBuffer()
                    .append(returnValue.substring(0, i))
                    .append(' ')
                    .append(returnValue.substring(i+1))
                    .toString();
                }
            } else if (ch == '"') {
                returnValue = new StringBuffer()
                    .append(returnValue.substring(0, i))
                    .append("&quot;")
                    .append(returnValue.substring(i+1))
                    .toString();
            } else if (ch == '&') {
                returnValue = new StringBuffer()
                    .append(returnValue.substring(0, i))
                    .append("&amp;")
                    .append(returnValue.substring(i+1))
                    .toString();
            } else if (ch == '>') {
                returnValue = new StringBuffer()
                    .append(returnValue.substring(0, i))
                    .append("&gt;")
                    .append(returnValue.substring(i+1))
                    .toString();
            } else if (ch == '<') {