com.feilong.lib.xstream.converters.extended.SubjectConverter Maven / Gradle / Ivy

Show more of this group Show more artifacts with this name
Show all versions of feilong Show documentation
feilong is a suite of core and expanded libraries that include utility classes, http, excel,cvs, io classes, and much much more.
There is a newer version: 4.0.8
Show newest version
/*
 * Copyright (C) 2006, 2007, 2018 XStream Committers.
 * All rights reserved.
 *
 * The software in this package is published under the terms of the BSD
 * style license a copy of which has been included with this distribution in
 * the LICENSE.txt file.
 * 
 * Created on 12. January 2006 by Joerg Schaible
 */
package com.feilong.lib.xstream.converters.extended;

import java.util.Collections;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

import javax.security.auth.Subject;

import com.feilong.lib.xstream.converters.MarshallingContext;
import com.feilong.lib.xstream.converters.UnmarshallingContext;
import com.feilong.lib.xstream.converters.collections.AbstractCollectionConverter;
import com.feilong.lib.xstream.io.HierarchicalStreamReader;
import com.feilong.lib.xstream.io.HierarchicalStreamWriter;
import com.feilong.lib.xstream.mapper.Mapper;

/**
 * Converts a {@link Subject} instance. Note, that this Converter does only convert the contained Principals as
 * it is done by JDK serialization, but not any credentials. For other behaviour you can derive your own converter,
 * overload the appropriate methods and register it in the {@link com.feilong.lib.xstream.XStream}.
 *
 * @author Jörg Schaible
 * @since 1.1.3
 */
public class SubjectConverter extends AbstractCollectionConverter{

    public SubjectConverter(Mapper mapper){
        super(mapper);
    }

    @Override
    public boolean canConvert(Class type){
        return type == Subject.class;
    }

    @Override
    public void marshal(Object source,HierarchicalStreamWriter writer,MarshallingContext context){
        Subject subject = (Subject) source;
        marshalPrincipals(subject.getPrincipals(), writer, context);
        marshalPublicCredentials(subject.getPublicCredentials(), writer, context);
        marshalPrivateCredentials(subject.getPrivateCredentials(), writer, context);
        marshalReadOnly(subject.isReadOnly(), writer);
    }

    protected void marshalPrincipals(Set principals,HierarchicalStreamWriter writer,MarshallingContext context){
        writer.startNode("principals");
        for (final Iterator iter = principals.iterator(); iter.hasNext();){
            final Object principal = iter.next(); // pre jdk 1.4 a Principal was also in javax.security
            writeCompleteItem(principal, context, writer);
        }
        writer.endNode();
    }

    protected void marshalPublicCredentials(Set pubCredentials,HierarchicalStreamWriter writer,MarshallingContext context){
    }

    protected void marshalPrivateCredentials(Set privCredentials,HierarchicalStreamWriter writer,MarshallingContext context){
    }

    protected void marshalReadOnly(boolean readOnly,HierarchicalStreamWriter writer){
        writer.startNode("readOnly");
        writer.setValue(String.valueOf(readOnly));
        writer.endNode();
    }

    @Override
    public Object unmarshal(HierarchicalStreamReader reader,UnmarshallingContext context){
        Set principals = unmarshalPrincipals(reader, context);
        Set publicCredentials = unmarshalPublicCredentials(reader, context);
        Set privateCredentials = unmarshalPrivateCredentials(reader, context);
        boolean readOnly = unmarshalReadOnly(reader);
        return new Subject(readOnly, principals, publicCredentials, privateCredentials);
    }

    protected Set unmarshalPrincipals(HierarchicalStreamReader reader,UnmarshallingContext context){
        return populateSet(reader, context);
    }

    protected Set unmarshalPublicCredentials(HierarchicalStreamReader reader,UnmarshallingContext context){
        return Collections.EMPTY_SET;
    }

    protected Set unmarshalPrivateCredentials(HierarchicalStreamReader reader,UnmarshallingContext context){
        return Collections.EMPTY_SET;
    }

    protected boolean unmarshalReadOnly(HierarchicalStreamReader reader){
        reader.moveDown();
        boolean readOnly = Boolean.getBoolean(reader.getValue());
        reader.moveUp();
        return readOnly;
    }

    protected Set populateSet(HierarchicalStreamReader reader,UnmarshallingContext context){
        Set set = new HashSet();
        reader.moveDown();
        while (reader.hasMoreChildren()){
            final Object principal = readCompleteItem(reader, context, set);
            set.add(principal);
        }
        reader.moveUp();
        return set;
    }
}