com.thoughtworks.xstream.InitializationException Java Examples

private void processAliasAnnotation(final Class<?> type, final Set<Class<?>> types) {
    final XStreamAlias aliasAnnotation = type.getAnnotation(XStreamAlias.class);
    if (aliasAnnotation != null) {
        if (classAliasingMapper == null) {
            throw new InitializationException("No "
                + ClassAliasingMapper.class.getName()
                + " available");
        }
        classAliasingMapper.addClassAlias(aliasAnnotation.value(), type);
        if (aliasAnnotation.impl() != Void.class) {
            // Alias for Interface/Class with an impl
            defaultImplementationsMapper.addDefaultImplementation(
                aliasAnnotation.impl(), type);
            if (type.isInterface()) {
                types.add(aliasAnnotation.impl()); // alias Interface's impl
            }
        }
    }
}
 

private static <T extends Enum<T>> Map<String, T> extractStringMap(Class<T> type) {
    checkType(type);
    EnumSet<T> values = EnumSet.allOf(type);
    Map<String, T> strings = new HashMap<String, T>(values.size());
    for (T value : values) {
        if (strings.put(value.toString(), value) != null) {
            throw new InitializationException("Enum type "
                + type.getName()
                + " does not have unique string representations for its values");
        }
    }
    return strings;
}
 

private void processConverterAnnotations(final Class<?> type) {
    if (converterRegistry != null) {
        final XStreamConverters convertersAnnotation = type
            .getAnnotation(XStreamConverters.class);
        final XStreamConverter converterAnnotation = type
            .getAnnotation(XStreamConverter.class);
        final List<XStreamConverter> annotations = convertersAnnotation != null
            ? new ArrayList<XStreamConverter>(Arrays.asList(convertersAnnotation.value()))
            : new ArrayList<XStreamConverter>();
        if (converterAnnotation != null) {
            annotations.add(converterAnnotation);
        }
        for (final XStreamConverter annotation : annotations) {
            final Converter converter = cacheConverter(
                annotation, converterAnnotation != null ? type : null);
            if (converter != null) {
                if (converterAnnotation != null || converter.canConvert(type)) {
                    converterRegistry.registerConverter(converter, annotation.priority());
                } else {
                    throw new InitializationException("Converter "
                        + annotation.value().getName()
                        + " cannot handle annotated class "
                        + type.getName());
                }
            }
        }
    }
}
 

private void processAliasTypeAnnotation(final Class<?> type) {
    final XStreamAliasType aliasAnnotation = type.getAnnotation(XStreamAliasType.class);
    if (aliasAnnotation != null) {
        if (classAliasingMapper == null) {
            throw new InitializationException("No "
                + ClassAliasingMapper.class.getName()
                + " available");
        }
        classAliasingMapper.addTypeAlias(aliasAnnotation.value(), type);
    }
}
 

@Deprecated
private void processImplicitCollectionAnnotation(final Class<?> type) {
    final XStreamImplicitCollection implicitColAnnotation = type
        .getAnnotation(XStreamImplicitCollection.class);
    if (implicitColAnnotation != null) {
        if (implicitCollectionMapper == null) {
            throw new InitializationException("No "
                + ImplicitCollectionMapper.class.getName()
                + " available");
        }
        final String fieldName = implicitColAnnotation.value();
        final String itemFieldName = implicitColAnnotation.item();
        final Field field;
        try {
            field = type.getDeclaredField(fieldName);
        } catch (final NoSuchFieldException e) {
            throw new InitializationException(type.getName()
                + " does not have a field named '"
                + fieldName
                + "' as required by "
                + XStreamImplicitCollection.class.getName());
        }
        Class itemType = null;
        final Type genericType = field.getGenericType();
        if (genericType instanceof ParameterizedType) {
            final Type typeArgument = ((ParameterizedType)genericType)
                .getActualTypeArguments()[0];
            itemType = getClass(typeArgument);
        }
        if (itemType == null) {
            implicitCollectionMapper.add(type, fieldName, null, Object.class);
        } else {
            if (itemFieldName.equals("")) {
                implicitCollectionMapper.add(type, fieldName, null, itemType);
            } else {
                implicitCollectionMapper.add(type, fieldName, itemFieldName, itemType);
            }
        }
    }
}
 

private void processFieldAliasAnnotation(final Field field) {
    final XStreamAlias aliasAnnotation = field.getAnnotation(XStreamAlias.class);
    if (aliasAnnotation != null) {
        if (fieldAliasingMapper == null) {
            throw new InitializationException("No "
                + FieldAliasingMapper.class.getName()
                + " available");
        }
        fieldAliasingMapper.addFieldAlias(
            aliasAnnotation.value(), field.getDeclaringClass(), field.getName());
    }
}
 

private void processAsAttributeAnnotation(final Field field) {
    final XStreamAsAttribute asAttributeAnnotation = field
        .getAnnotation(XStreamAsAttribute.class);
    if (asAttributeAnnotation != null) {
        if (attributeMapper == null) {
            throw new InitializationException("No "
                + AttributeMapper.class.getName()
                + " available");
        }
        attributeMapper.addAttributeFor(field);
    }
}
 

private void processImplicitAnnotation(final Field field) {
    final XStreamImplicit implicitAnnotation = field.getAnnotation(XStreamImplicit.class);
    if (implicitAnnotation != null) {
        if (implicitCollectionMapper == null) {
            throw new InitializationException("No "
                + ImplicitCollectionMapper.class.getName()
                + " available");
        }
        final String fieldName = field.getName();
        final String itemFieldName = implicitAnnotation.itemFieldName();
        final String keyFieldName = implicitAnnotation.keyFieldName();
        boolean isMap = Map.class.isAssignableFrom(field.getType());
        Class itemType = null;
        if (!field.getType().isArray()) {
            final Type genericType = field.getGenericType();
            if (genericType instanceof ParameterizedType) {
                final Type[] actualTypeArguments = ((ParameterizedType)genericType)
                    .getActualTypeArguments();
                final Type typeArgument = actualTypeArguments[isMap ? 1 : 0];
                itemType = getClass(typeArgument);
            }
        }
        if (isMap) {
            implicitCollectionMapper.add(
                field.getDeclaringClass(), fieldName,
                itemFieldName != null && !"".equals(itemFieldName) ? itemFieldName : null,
                itemType, keyFieldName != null && !"".equals(keyFieldName)
                    ? keyFieldName
                    : null);
        } else {
            if (itemFieldName != null && !"".equals(itemFieldName)) {
                implicitCollectionMapper.add(
                    field.getDeclaringClass(), fieldName, itemFieldName, itemType);
            } else {
                implicitCollectionMapper
                    .add(field.getDeclaringClass(), fieldName, itemType);
            }
        }
    }
}
 

private void processOmitFieldAnnotation(final Field field) {
    final XStreamOmitField omitFieldAnnotation = field
        .getAnnotation(XStreamOmitField.class);
    if (omitFieldAnnotation != null) {
        if (elementIgnoringMapper == null) {
            throw new InitializationException("No "
                + ElementIgnoringMapper.class.getName()
                + " available");
        }
        elementIgnoringMapper.omitField(field.getDeclaringClass(), field.getName());
    }
}
 

private void processLocalConverterAnnotation(final Field field) {
    final XStreamConverter annotation = field.getAnnotation(XStreamConverter.class);
    if (annotation != null) {
        final Converter converter = cacheConverter(annotation, field.getType());
        if (converter != null) {
            if (localConversionMapper == null) {
                throw new InitializationException("No "
                    + LocalConversionMapper.class.getName()
                    + " available");
            }
            localConversionMapper.registerLocalConverter(
                field.getDeclaringClass(), field.getName(), converter);
        }
    }
}
 

public void addDefaultImplementation(Class defaultImplementation, Class ofType) {
    if (defaultImplementation != null && defaultImplementation.isInterface()) {
        throw new InitializationException(
            "Default implementation is not a concrete class: "
                + defaultImplementation.getName());
    }
    typeToImpl.put(ofType, defaultImplementation);
    implToType.put(defaultImplementation, ofType);
}
 

private VRaptorMatchers(){
	throw new InitializationException("Not allowed to initialize");
}
 

private HasConstructor(){
	throw new InitializationException("Not allowed to initialize");
}
 

private VRaptorMatchers(){
	throw new InitializationException("Not allowed to initialize");
}
 

private StringUtils(){
	throw new InitializationException("Not allowed to initialize");
}
 

private DownloadBuilder () {
	throw new InitializationException("Not allowed to initialize");
}
 

private CDIProxies(){
	throw new InitializationException("Not allowed to initialize");
}
 

private Results(){
	throw new InitializationException("Not allowed to initialize");
}
 

private static <T> void checkType(Class<T> type) {
    if (!Enum.class.isAssignableFrom(type) && type != Enum.class) {
        throw new InitializationException("Converter can only handle enum types");
    }
}