public void marshal()

in xstream/src/java/com/thoughtworks/xstream/converters/reflection/ExternalizableConverter.java [86:144]
55 lines of code
7 McCabe index (conditional complexity)

    public void marshal(final Object original, final HierarchicalStreamWriter writer,
            final MarshallingContext context) {
        final Object source = serializationMembers.callWriteReplace(original);
        if (source != original && context instanceof ReferencingMarshallingContext) {
            ((ReferencingMarshallingContext<?>)context).replace(original, source);
        }
        if (source.getClass() != original.getClass()) {
            final String attributeName = mapper.aliasForSystemAttribute("resolves-to");
            if (attributeName != null) {
                writer.addAttribute(attributeName, mapper.serializedClass(source.getClass()));
            }
            context.convertAnother(source);
        } else {
            try {
                final Externalizable externalizable = (Externalizable)source;
                final CustomObjectOutputStream.StreamCallback callback = new CustomObjectOutputStream.StreamCallback() {
                    @Override
                    public void writeToStream(final Object object) {
                        if (object == null) {
                            writer.startNode("null");
                            writer.endNode();
                        } else {
                            writer.startNode(mapper.serializedClass(object.getClass()), object.getClass());
                            context.convertAnother(object);
                            writer.endNode();
                        }
                    }

                    @Override
                    public void writeFieldsToStream(final Map<String, Object> fields) {
                        throw new UnsupportedOperationException();
                    }

                    @Override
                    public void defaultWriteObject() {
                        throw new UnsupportedOperationException();
                    }

                    @Override
                    public void flush() {
                        writer.flush();
                    }

                    @Override
                    public void close() {
                        throw new UnsupportedOperationException(
                            "Objects are not allowed to call ObjectOutput.close() from writeExternal()");
                    }
                };
                @SuppressWarnings("resource")
                final CustomObjectOutputStream objectOutput = CustomObjectOutputStream.getInstance(context, callback);
                externalizable.writeExternal(objectOutput);
                objectOutput.popCallback();
            } catch (final IOException e) {
                throw new StreamException("Cannot serialize " + source.getClass().getName() + " using Externalization",
                    e);
            }
        }
    }