Examples of org.apache.pivot.serialization.SerializationException

org.apache.pivot.serialization.SerializationException
Thrown when an error is encountered during serialization.


        ClassLoader classLoader = ThreadUtilities.getClassLoader();
        URL location = classLoader.getResource(resourceName);


        if (location == null) {
            throw new SerializationException("Could not find resource named \""
                + resourceName + "\".");
        }


        return readObject(location);
    }

View Full Code Here

                            break;
                        }
                    }
                }
            } catch (XMLStreamException exception) {
                throw new SerializationException(exception);
            }
        } catch (IOException exception) {
            logException(exception);
            throw exception;
        } catch (SerializationException exception) {

View Full Code Here


                        try {
                            Method addMethod = sequence.getClass().getMethod("add", String.class);
                            addMethod.invoke(sequence, text);
                        } catch (NoSuchMethodException exception) {
                            throw new SerializationException("Text content cannot be added to "
                                + sequence.getClass().getName() + ".", exception);
                        } catch (InvocationTargetException exception) {
                            throw new SerializationException(exception);
                        } catch (IllegalAccessException exception) {
                            throw new SerializationException(exception);
                        }
                    }


                    break;
                }


                case SCRIPT:
                case WRITABLE_PROPERTY: {
                    element.value = text;
                    break;
                }


                default: {
                    throw new SerializationException("Unexpected characters in "
                        + element.type + " element.");
                }
            }
        }
    }

View Full Code Here

                            + " must not be empty.");
                    }


                    id = attributeValue;
                } else {
                    throw new SerializationException(WTKX_PREFIX + ":" + attributeLocalName
                        + " is not a valid attribute.");
                }
            } else {
                String attributeNamespaceURI = xmlStreamReader.getAttributeNamespace(i);
                if (attributeNamespaceURI == null) {
                    attributeNamespaceURI = xmlStreamReader.getNamespaceURI("");
                }


                attributes.add(new Attribute(attributeNamespaceURI, attributeLocalName,
                    attributeValue));
            }
        }


        // Determine the type and value of this element
        Element.Type elementType = null;
        Object value = null;


        if (prefix != null
            && prefix.equals(WTKX_PREFIX)) {
            // The element represents a WTKX operation
            if (element == null) {
                throw new SerializationException(prefix + ":" + localName
                    + " is not a valid root element.");
            }


            if (localName.equals(INCLUDE_TAG)) {
                elementType = Element.Type.INCLUDE;
            } else if (localName.equals(SCRIPT_TAG)) {
                elementType = Element.Type.SCRIPT;
            } else if (localName.equals(DEFINE_TAG)) {
                if (attributes.getLength() > 0) {
                    throw new SerializationException(WTKX_PREFIX + ":" + DEFINE_TAG
                        + " cannot have attributes.");
                }


                elementType = Element.Type.DEFINE;
            } else {
                throw new SerializationException(prefix + ":" + localName
                    + " is not a valid element.");
            }
        } else {
            if (Character.isUpperCase(localName.charAt(0))) {
                // The element represents a typed object
                if (namespaceURI == null) {
                    throw new SerializationException("No XML namespace specified for "
                        + localName + " tag.");
                }


                String className = namespaceURI + "." + localName.replace('.', '$');


                try {
                    Class<?> type = Class.forName(className);
                    elementType = Element.Type.INSTANCE;
                    value = type.newInstance();
                } catch (Exception exception) {
                    throw new SerializationException(exception);
                }
            } else {
                // The element represents a property
                if (element == null
                    || element.type != Element.Type.INSTANCE) {
                    throw new SerializationException("Parent element must be a typed object.");
                }


                if (prefix != null
                    && prefix.length() > 0) {
                    throw new SerializationException("Property elements cannot have a namespace prefix.");
                }


                BeanDictionary beanDictionary = new BeanDictionary(element.value);


                if (beanDictionary.isReadOnly(localName)) {
                    elementType = Element.Type.READ_ONLY_PROPERTY;
                    value = beanDictionary.get(localName);
                    assert (value != null) : "Read-only properties cannot be null.";


                    if (attributes.getLength() > 0
                        && !(value instanceof Dictionary<?, ?>)) {
                        throw new SerializationException("Only read-only dictionaries can have attributes.");
                    }
                } else {
                    if (attributes.getLength() > 0) {
                        throw new SerializationException("Writable property elements cannot have attributes.");
                    }


                    elementType = Element.Type.WRITABLE_PROPERTY;
                }
            }

View Full Code Here

                            src = attribute.value;
                        } else if (attribute.localName.equals(INCLUDE_RESOURCES_ATTRIBUTE)) {
                            resources = new Resources(resources, attribute.value);
                        } else {
                            if (!Character.isUpperCase(attribute.localName.charAt(0))) {
                                throw new SerializationException("Instance property setters are not"
                                    + " supported for " + WTKX_PREFIX + ":" + INCLUDE_TAG
                                    + " " + " tag.");
                            }


                            staticPropertyAttributes.add(attribute);
                        }
                    }


                    if (src == null) {
                        throw new SerializationException(INCLUDE_SRC_ATTRIBUTE
                            + " attribute is required for " + WTKX_PREFIX + ":" + INCLUDE_TAG
                            + " tag.");
                    }


                    // Read the object
                    WTKXSerializer serializer;
                    if (element.id == null) {
                        serializer = new WTKXSerializer(resources, namedObjects, namedSerializers);
                    } else {
                        serializer = new WTKXSerializer(resources);
                        namedSerializers.put(element.id, serializer);
                    }


                    if (src.charAt(0) == '/') {
                        element.value = serializer.readObject(src.substring(1));
                    } else {
                        element.value = serializer.readObject(new URL(location, src));
                    }


                    if (element.id == null
                        && !serializer.isEmpty()
                        && serializer.scriptEngineManager == null) {
                        System.err.println("Include \"" + src + "\" defines unreachable objects.");
                    }
                } else {
                    // Process attributes looking for all property setters
                    for (Attribute attribute : element.attributes) {
                        if (Character.isUpperCase(attribute.localName.charAt(0))) {
                            staticPropertyAttributes.add(attribute);
                        } else {
                            instancePropertyAttributes.add(attribute);
                        }
                    }
                }


                // Add the value to the named objects map
                if (element.id != null) {
                    namedObjects.put(element.id, element.value);
                }


                // Apply instance attributes
                Dictionary<String, Object> dictionary;
                if (element.value instanceof Dictionary<?, ?>) {
                    dictionary = (Dictionary<String, Object>)element.value;
                } else {
                    dictionary = new BeanDictionary(element.value);
                }


                for (Attribute attribute : instancePropertyAttributes) {
                    dictionary.put(attribute.localName, resolve(attribute.value));
                }


                // If the element's parent is a sequence or a listener list, add
                // the element value to it
                if (element.parent != null) {
                    if (element.parent.value instanceof Sequence<?>) {
                        Sequence<Object> sequence = (Sequence<Object>)element.parent.value;
                        sequence.add(element.value);
                    } else {
                        if (element.parent.value instanceof ListenerList<?>) {
                            ListenerList<Object> listenerList = (ListenerList<Object>)element.parent.value;
                            listenerList.add(element.value);
                        }
                    }
                }


                // Apply static attributes
                if (element.value instanceof Dictionary<?, ?>) {
                    if (staticPropertyAttributes.getLength() > 0) {
                        throw new SerializationException("Static setters are only supported"
                            + " for typed objects.");
                    }
                } else {
                    for (Attribute attribute : staticPropertyAttributes) {
                        // Determine the type of the attribute
                        String propertyClassName = attribute.namespaceURI + "."
                            + attribute.localName.substring(0, attribute.localName.lastIndexOf("."));


                        Class<?> propertyClass = null;
                        try {
                            propertyClass = Class.forName(propertyClassName);
                        } catch (ClassNotFoundException exception) {
                            throw new SerializationException(exception);
                        }


                        if (propertyClass.isInterface()) {
                            // The attribute represents an event listener
                            String listenerClassName = propertyClassName.substring(propertyClassName.lastIndexOf('.') + 1);
                            String getListenerListMethodName = "get" + Character.toUpperCase(listenerClassName.charAt(0))
                                + listenerClassName.substring(1) + "s";


                            // Get the listener list
                            Method getListenerListMethod;
                            try {
                                Class<?> type = element.value.getClass();
                                getListenerListMethod = type.getMethod(getListenerListMethodName);
                            } catch (NoSuchMethodException exception) {
                                throw new SerializationException(exception);
                            }


                            Object listenerList;
                            try {
                                listenerList = getListenerListMethod.invoke(element.value);
                            } catch (InvocationTargetException exception) {
                                throw new SerializationException(exception);
                            } catch (IllegalAccessException exception) {
                                throw new SerializationException(exception);
                            }


                            // Don't pollute the engine namespace with the listener functions
                            ScriptEngine scriptEngine = scriptEngineManager.getEngineByName(language);
                            scriptEngine.setBindings(new SimpleBindings(), ScriptContext.ENGINE_SCOPE);


                            // Create an invocation handler for this listener
                            AttributeInvocationHandler handler =
                                new AttributeInvocationHandler(scriptEngine,
                                    attribute.localName.substring(attribute.localName.lastIndexOf(".") + 1),
                                    attribute.value);


                            Object listener = Proxy.newProxyInstance(ThreadUtilities.getClassLoader(),
                                new Class<?>[]{propertyClass}, handler);


                            // Add the listener
                            Class<?> listenerListClass = listenerList.getClass();
                            Method addMethod;
                            try {
                                addMethod = listenerListClass.getMethod("add", Object.class);
                            } catch (NoSuchMethodException exception) {
                                throw new RuntimeException(exception);
                            }


                            try {
                                addMethod.invoke(listenerList, listener);
                            } catch (IllegalAccessException exception) {
                                throw new SerializationException(exception);
                            } catch (InvocationTargetException exception) {
                                throw new SerializationException(exception);
                            }
                        } else {
                            // The attribute reprsents a static setter
                            Object value = resolve(attribute.value);


                            Class<?> objectType = element.value.getClass();


                            String propertyName = attribute.localName.substring(attribute.localName.lastIndexOf(".") + 1);
                            propertyName = Character.toUpperCase(propertyName.charAt(0)) +
                            propertyName.substring(1);


                            Method setterMethod = null;
                            if (value != null) {
                                setterMethod = getStaticSetterMethod(propertyClass, propertyName,
                                    objectType, value.getClass());
                            }


                            if (setterMethod == null) {
                                Method getterMethod = getStaticGetterMethod(propertyClass, propertyName, objectType);


                                if (getterMethod != null) {
                                    Class<?> propertyType = getterMethod.getReturnType();
                                    setterMethod = getStaticSetterMethod(propertyClass, propertyName,
                                        objectType, propertyType);


                                    if (value instanceof String) {
                                        value = BeanDictionary.coerce((String)value, propertyType);
                                    }
                                }
                            }


                            if (setterMethod == null) {
                                throw new SerializationException(attribute.localName + " is not valid static property.");
                            }


                            // Invoke the setter
                            try {
                                setterMethod.invoke(null, element.value, value);
                            } catch (Exception exception) {
                                throw new SerializationException(exception);
                            }
                        }
                    }
                }


                // If the parent element is a writable property, set this as its
                // value; it will be applied later in the parent's closing tag
                if (element.parent != null
                    && element.parent.type == Element.Type.WRITABLE_PROPERTY) {
                    element.parent.value = element.value;
                }


                break;
            }


            case READ_ONLY_PROPERTY: {
                if (element.value instanceof Dictionary<?, ?>) {
                    // Process attributes looking for instance property setters
                    for (Attribute attribute : element.attributes) {
                        if (Character.isUpperCase(attribute.localName.charAt(0))) {
                            throw new SerializationException("Static setters are not supported"
                                + " for read-only properties.");
                        }


                        Dictionary<String, Object> dictionary =
                            (Dictionary<String, Object>)element.value;
                        dictionary.put(attribute.localName, resolve(attribute.value));
                    }
                }


                break;
            }


            case WRITABLE_PROPERTY: {
                BeanDictionary beanDictionary = new BeanDictionary(element.parent.value);
                beanDictionary.put(localName, element.value);
                break;
            }


            case SCRIPT: {
                // Process attributes looking for src and language
                String src = null;
                String language = this.language;
                for (Attribute attribute : element.attributes) {
                    if (attribute.localName.equals(SCRIPT_SRC_ATTRIBUTE)) {
                        src = attribute.value;
                    } else if (attribute.localName.equals(SCRIPT_LANGUAGE_ATTRIBUTE)) {
                        language = attribute.value;
                    } else {
                        throw new SerializationException(attribute.localName + " is not a valid"
                            + " attribute for the " + WTKX_PREFIX + ":" + SCRIPT_TAG + " tag.");
                    }
                }


                Bindings bindings;
                if (element.parent.value instanceof ListenerList<?>) {
                    // Don't pollute the engine namespace with the listener functions
                    bindings = new SimpleBindings();
                } else {
                    bindings = scriptEngineManager.getBindings();
                }


                // Execute script
                final ScriptEngine scriptEngine;


                if (src != null) {
                    // The script is located in an external file
                    int i = src.lastIndexOf(".");
                    if (i == -1) {
                        throw new SerializationException("Cannot determine type of script \""
                            + src + "\".");
                    }


                    String extension = src.substring(i + 1);
                    scriptEngine = scriptEngineManager.getEngineByExtension(extension);


                    if (scriptEngine == null) {
                        throw new SerializationException("Unable to find scripting engine for"
                            + " extension " + extension + ".");
                    }


                    scriptEngine.setBindings(bindings, ScriptContext.ENGINE_SCOPE);


                    try {
                        URL scriptLocation;
                        if (src.charAt(0) == '/') {
                            ClassLoader classLoader = ThreadUtilities.getClassLoader();
                            scriptLocation = classLoader.getResource(src);
                        } else {
                            scriptLocation = new URL(location, src);
                        }


                        BufferedReader scriptReader = null;
                        try {
                            scriptReader = new BufferedReader(new InputStreamReader(scriptLocation.openStream()));
                            scriptEngine.eval(scriptReader);
                        } catch(ScriptException exception) {
                            exception.printStackTrace();
                        } finally {
                            if (scriptReader != null) {
                                scriptReader.close();
                            }
                        }
                    } catch (IOException exception) {
                        throw new SerializationException(exception);
                    }
                } else {
                    // The script is inline
                    scriptEngine = scriptEngineManager.getEngineByName(language);


                    if (scriptEngine == null) {
                        throw new SerializationException("Unable to find scripting engine for"
                            + " language \"" + language + "\".");
                    }


                    scriptEngine.setBindings(bindings, ScriptContext.ENGINE_SCOPE);


                    String script = (String)element.value;
                    if (script != null) {
                        try {
                            scriptEngine.eval(script);
                        } catch (ScriptException exception) {
                            System.err.println(exception);
                            System.err.println(script);
                        }
                    }
                }


                if (element.parent.value instanceof ListenerList<?>) {
                    // Create the listener and add it to the list
                    Class<?> listenerListClass = element.parent.value.getClass();


                    java.lang.reflect.Type[] genericInterfaces = listenerListClass.getGenericInterfaces();
                    Class<?> listenerClass = (Class<?>)genericInterfaces[0];


                    ElementInvocationHandler handler = new ElementInvocationHandler(scriptEngine);


                    Method addMethod;
                    try {
                        addMethod = listenerListClass.getMethod("add", Object.class);
                    } catch (NoSuchMethodException exception) {
                        throw new RuntimeException(exception);
                    }


                    Object listener = Proxy.newProxyInstance(ThreadUtilities.getClassLoader(),
                        new Class<?>[]{listenerClass}, handler);


                    try {
                        addMethod.invoke(element.parent.value, listener);
                    } catch (IllegalAccessException exception) {
                        throw new SerializationException(exception);
                    } catch (InvocationTargetException exception) {
                        throw new SerializationException(exception);
                    }
                }


                break;
            }

View Full Code Here

            if (bindings.containsKey(methodName)) {
                Invocable invocable;
                try {
                    invocable = (Invocable)scriptEngine;
                } catch (ClassCastException exception) {
                    throw new SerializationException(exception);
                }


                result = invocable.invokeFunction(methodName, args);
            }

View Full Code Here

                        break;
                    }
                }
            }
        } catch (XMLStreamException exception) {
            throw new SerializationException(exception);
        }


        return document;
    }

View Full Code Here

            XMLStreamWriter xmlStreamWriter = output.createXMLStreamWriter(writer);
            xmlStreamWriter.writeStartDocument();
            writeElement(element, xmlStreamWriter);
            xmlStreamWriter.writeEndDocument();
        } catch (XMLStreamException exception) {
            throw new SerializationException(exception);
        }
    }

View Full Code Here

            if (node instanceof Element) {
                writeElement((Element)node, xmlStreamWriter);
            } else if (node instanceof TextNode) {
                writeTextNode((TextNode)node, xmlStreamWriter);
            } else {
                throw new SerializationException("Unsupported node type: "
                    + node.getClass().getName());
            }
        }


        if (element.getLength() > 0) {

View Full Code Here

        Object object = null;


        skipWhitespaceAndComments(reader);


        if (c == -1) {
            throw new SerializationException("Unexpected end of input stream.");
        }


        if (c == 'n') {
            object = readNullValue(reader);
        } else if (c == '"' || c == '\'') {
            object = readStringValue(reader, typeArgument);
        } else if (c == '+' || c == '-' || Character.isDigit(c)) {
            object = readNumberValue(reader, typeArgument);
        } else if (c == 't' || c == 'f') {
            object = readBooleanValue(reader, typeArgument);
        } else if (c == '[') {
            object = readListValue(reader, typeArgument);
        } else if (c == '{') {
            object = readMapValue(reader, typeArgument);
        } else {
            throw new SerializationException("Unexpected character in input stream.");
        }


        return object;
    }

View Full Code Here

0 1 2 3 4 5 6 7 8 9

TOP

Related Classes of org.apache.pivot.serialization.SerializationException

org.apache.pivot.beans.BXMLSerializer

org.apache.pivot.beans.BXMLSerializer$ElementInvocationHandler

org.apache.pivot.json.JSONSerializer

org.apache.pivot.wtkx.WTKXSerializer

org.apache.pivot.wtkx.WTKXSerializer$ElementInvocationHandler

org.apache.pivot.xml.XMLSerializer

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.