package net.gcdc.asn1.uper;
import java.lang.annotation.Annotation;
import java.lang.reflect.Field;
import java.lang.reflect.ParameterizedType;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import net.gcdc.asn1.datatypes.FixedSize;
import net.gcdc.asn1.datatypes.SizeRange;
import net.gcdc.asn1.uper.SimpleTypeResolver.Unknown;
class SeqOfCoder implements Decoder, Encoder {
@Override public <T> boolean canEncode(T obj, Annotation[] extraAnnotations) {
return obj instanceof List<?>;
}
@Override public <T> void encode(BitBuffer bitbuffer, T obj, Annotation[] extraAnnotations) throws Asn1EncodingException {
Class<?> type = obj.getClass();
UperEncoder.logger.debug(String.format("SEQUENCE OF %s",obj.getClass().getName()));
AnnotationStore annotations = new AnnotationStore(type.getAnnotations(), extraAnnotations);
List<?> list = (List<?>) obj;
final FixedSize fixedSize = annotations.getAnnotation(FixedSize.class);
//CG pass annotations too each field encoding
Annotation[] annotationArray = new Annotation[] {};
if (annotations != null & annotations.getAnnotations() != null && !annotations.getAnnotations().isEmpty()) {
ArrayList<Annotation> fieldAnnotations = new ArrayList<Annotation>();
fieldAnnotations.addAll(annotations.getAnnotations());
annotationArray = new Annotation[fieldAnnotations.size()];
for (int i = 0; i< fieldAnnotations.size();i++){
annotationArray[i] = fieldAnnotations.get(i);
}
}
SizeRange sizeRange = annotations.getAnnotation(SizeRange.class);
if (fixedSize != null)
sizeRange = new SizeRange() {
@Override public Class<? extends Annotation> annotationType() { return SizeRange.class; }
@Override public int minValue() { return fixedSize.value(); }
@Override public int maxValue() { return fixedSize.value(); }
@Override public boolean hasExtensionMarker() { return false; }
};
if (sizeRange == null) {
int position1 = bitbuffer.position();
try {
UperEncoder.encodeLengthDeterminant(bitbuffer, list.size());
} catch (Asn1EncodingException e) {
throw new Asn1EncodingException(" number of elements ", e);
}
UperEncoder.logger.debug(String.format("unbound size %d, encoded as %s", list.size(),
bitbuffer.toBooleanStringFromPosition(position1)));
UperEncoder.logger.debug(String.format(" all elems of Seq Of: %s", list ));
for (Object elem : list) {
try {
UperEncoder.encode2(bitbuffer, elem, annotationArray);
} catch (Asn1EncodingException e) {
throw new Asn1EncodingException(" element " + elem.toString(), e);
}
}
return;
}
boolean outsideOfRange = list.size() < sizeRange.minValue()
|| sizeRange.maxValue() < list.size();
if (outsideOfRange && !sizeRange.hasExtensionMarker()) { throw new IllegalArgumentException(
"Out-of-range size for " + obj.getClass() + ", expected " +
sizeRange.minValue() + ".." + sizeRange.maxValue() + ", got "
+ list.size()); }
if (sizeRange.hasExtensionMarker()) {
bitbuffer.put(outsideOfRange);
UperEncoder.logger.debug(String.format("With Extension Marker, %s of range (%d <= %d <= %d)",
(outsideOfRange ? "outside" : "inside"), sizeRange.minValue(), list.size(),
sizeRange.maxValue()));
if (outsideOfRange) { throw new UnsupportedOperationException(
"Sequence-of size range extensions are not implemented yet, range " +
sizeRange.minValue() + ".." + sizeRange.maxValue()
+ ", requested size " + list.size()); }
}
UperEncoder.logger.debug(String.format("seq-of of constrained size %d, encoding size...", list.size()));
UperEncoder.encodeConstrainedInt(bitbuffer, list.size(), sizeRange.minValue(), sizeRange.maxValue());
UperEncoder.logger.debug(String.format(" all elems of Seq Of: %s", list));
for (Object elem : list) {
UperEncoder.encode2(bitbuffer, elem, new Annotation[] {});
}
}
@Override public <T> boolean canDecode(Class<T> classOfT, Annotation[] extraAnnotations) {
return List.class.isAssignableFrom(classOfT);
}
@SuppressWarnings("unchecked")
@Override public <T> T decode(BitBuffer bitbuffer,
Class<T> classOfT,Field field,
Annotation[] extraAnnotations) {
AnnotationStore annotations = new AnnotationStore(classOfT.getAnnotations(),
extraAnnotations);
UperEncoder.logger.debug(String.format("SEQUENCE OF for %s", classOfT));
FixedSize fixedSize = annotations.getAnnotation(FixedSize.class);
SizeRange sizeRange = annotations.getAnnotation(SizeRange.class);
//CG pass annotations from the sequence to each element encoding
Annotation[] annotationArray = new Annotation[] {};
if (annotations != null && annotations.getAnnotations() != null && !annotations.getAnnotations().isEmpty()){
annotationArray = new Annotation[annotations.getAnnotations().size()];
Iterator<Annotation> it = annotations.getAnnotations().iterator();
int i = 0;
while (it.hasNext()) {
annotationArray[i] = it.next();
i++;
}
}
long size =
(fixedSize != null) ? fixedSize.value() :
(sizeRange != null) ? UperEncoder.decodeConstrainedInt(bitbuffer, UperEncoder.intRangeFromSizeRange(sizeRange)) :
UperEncoder.decodeLengthDeterminant(bitbuffer);
Collection<Object> coll = new ArrayList<Object>((int) size);
Class<?> classOfElements;
Class<?>[] typeArgs = SimpleTypeResolver.resolveRawArguments(List.class, classOfT);
classOfElements = typeArgs[0];
if (classOfElements == null || classOfElements == Unknown.class) {
try {
ParameterizedType elementType = (ParameterizedType) field.getGenericType();
classOfElements = (Class<?>) elementType.getActualTypeArguments()[0];
} catch (SecurityException e) {
throw new IllegalArgumentException("Can't resolve type of elements for " + classOfT.getName());
}
}
for (int i = 0; i < size; i++) {
coll.add(UperEncoder.decodeAny(bitbuffer, classOfElements,field, annotationArray));
}
T result = null;
try {
result = UperEncoder.instantiate(classOfT, coll);
} catch (Exception e) {
result = (T) coll;
}
return result;
}
@Override
public <T> T getDefault(Class<T> classOfT, Annotation[] extraAnnotations) {
throw new IllegalArgumentException("Default Sequence not yet implemented");
}
}
