X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?p=controller.git;a=blobdiff_plain;f=opendaylight%2Fmd-sal%2Fsal-binding-broker%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fcontroller%2Fsal%2Fbinding%2Fdom%2Fserializer%2Fimpl%2FLazyGeneratedCodecRegistry.java;h=cabb1bc4e2c5359582bc95e1e30514f557801b64;hp=b81100836f7a422cdebca5de63010e512e5d7ac0;hb=9212fed678702583f4a555641208cf1c7b45b829;hpb=4bf903ba60c5bb2b5cdde1c7282e9a93e27e49c8 diff --git a/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/sal/binding/dom/serializer/impl/LazyGeneratedCodecRegistry.java b/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/sal/binding/dom/serializer/impl/LazyGeneratedCodecRegistry.java index b81100836f..cabb1bc4e2 100644 --- a/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/sal/binding/dom/serializer/impl/LazyGeneratedCodecRegistry.java +++ b/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/sal/binding/dom/serializer/impl/LazyGeneratedCodecRegistry.java @@ -1,8 +1,9 @@ package org.opendaylight.controller.sal.binding.dom.serializer.impl; +import java.awt.CompositeContext; import java.lang.ref.WeakReference; import java.lang.reflect.Field; -import java.util.AbstractMap.SimpleEntry; +import java.lang.reflect.ParameterizedType; import java.util.ArrayList; import java.util.Collection; import java.util.Collections; @@ -13,11 +14,13 @@ import java.util.List; import java.util.Map; import java.util.Map.Entry; import java.util.Objects; +import java.util.concurrent.Callable; import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.ConcurrentMap; import java.util.Set; import java.util.WeakHashMap; +import org.apache.commons.lang3.text.translate.AggregateTranslator; import org.opendaylight.controller.sal.binding.dom.serializer.api.AugmentationCodec; import org.opendaylight.controller.sal.binding.dom.serializer.api.ChoiceCaseCodec; import org.opendaylight.controller.sal.binding.dom.serializer.api.ChoiceCodec; @@ -25,8 +28,10 @@ import org.opendaylight.controller.sal.binding.dom.serializer.api.CodecRegistry; import org.opendaylight.controller.sal.binding.dom.serializer.api.DataContainerCodec; import org.opendaylight.controller.sal.binding.dom.serializer.api.DomCodec; import org.opendaylight.controller.sal.binding.dom.serializer.api.IdentifierCodec; +import org.opendaylight.controller.sal.binding.dom.serializer.api.IdentitityCodec; import org.opendaylight.controller.sal.binding.dom.serializer.api.InstanceIdentifierCodec; import org.opendaylight.controller.sal.binding.dom.serializer.api.ValueWithQName; +import org.opendaylight.controller.sal.binding.impl.util.ClassLoaderUtils; import org.opendaylight.controller.sal.core.api.model.SchemaServiceListener; import org.opendaylight.yangtools.binding.generator.util.ReferencedTypeImpl; import org.opendaylight.yangtools.binding.generator.util.Types; @@ -34,6 +39,7 @@ import org.opendaylight.yangtools.concepts.Delegator; import org.opendaylight.yangtools.concepts.Identifiable; import org.opendaylight.yangtools.yang.binding.Augmentable; import org.opendaylight.yangtools.yang.binding.Augmentation; +import org.opendaylight.yangtools.yang.binding.BaseIdentity; import org.opendaylight.yangtools.yang.binding.BindingCodec; import org.opendaylight.yangtools.yang.binding.DataContainer; import org.opendaylight.yangtools.yang.binding.DataObject; @@ -41,6 +47,9 @@ import org.opendaylight.yangtools.yang.binding.Identifier; import org.opendaylight.yangtools.yang.common.QName; import org.opendaylight.yangtools.yang.data.api.CompositeNode; import org.opendaylight.yangtools.yang.data.api.Node; +import org.opendaylight.yangtools.yang.data.impl.CompositeNodeTOImpl; +import org.opendaylight.yangtools.yang.model.api.AugmentationSchema; +import org.opendaylight.yangtools.yang.model.api.AugmentationTarget; import org.opendaylight.yangtools.yang.model.api.ChoiceCaseNode; import org.opendaylight.yangtools.yang.model.api.ChoiceNode; import org.opendaylight.yangtools.yang.model.api.DataNodeContainer; @@ -49,6 +58,7 @@ import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode; import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode; import org.opendaylight.yangtools.yang.model.api.SchemaContext; import org.opendaylight.yangtools.yang.model.api.SchemaPath; +import org.opendaylight.yangtools.yang.model.api.UsesNode; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -58,10 +68,14 @@ import static org.opendaylight.controller.sal.binding.dom.serializer.impl.Interm import org.opendaylight.yangtools.sal.binding.generator.impl.ModuleContext; import org.opendaylight.yangtools.sal.binding.model.api.ConcreteType; import org.opendaylight.yangtools.sal.binding.model.api.Type; +import org.opendaylight.yangtools.sal.binding.model.api.type.builder.GeneratedTOBuilder; import org.opendaylight.yangtools.sal.binding.model.api.type.builder.GeneratedTypeBuilder; import org.opendaylight.yangtools.yang.model.api.Module; import org.opendaylight.yangtools.yang.model.util.SchemaContextUtil; +import com.google.common.collect.FluentIterable; +import com.google.common.util.concurrent.CycleDetectingLockFactory.WithExplicitOrdering; + public class LazyGeneratedCodecRegistry implements // CodecRegistry, // SchemaServiceListener, // @@ -71,26 +85,31 @@ public class LazyGeneratedCodecRegistry implements // private final static LateMixinCodec NOT_READY_CODEC = new LateMixinCodec(); private final InstanceIdentifierCodec instanceIdentifierCodec = new InstanceIdentifierCodecImpl(this); + private final IdentityCompositeCodec identityRefCodec = new IdentityCompositeCodec(); private TransformerGenerator generator; // Concrete class to codecs - private Map, DataContainerCodec> containerCodecs = new WeakHashMap<>(); - private Map, IdentifierCodec> identifierCodecs = new WeakHashMap<>(); - private Map, ChoiceCodecImpl> choiceCodecs = new WeakHashMap<>(); - private Map, ChoiceCaseCodecImpl> caseCodecs = new WeakHashMap<>(); - private Map, AugmentableCompositeCodec> augmentableCodecs = new WeakHashMap<>(); - + private static final Map, DataContainerCodec> containerCodecs = new WeakHashMap<>(); + private static final Map, IdentifierCodec> identifierCodecs = new WeakHashMap<>(); + private static final Map, ChoiceCodecImpl> choiceCodecs = new WeakHashMap<>(); + private static final Map, ChoiceCaseCodecImpl> caseCodecs = new WeakHashMap<>(); + private static final Map, AugmentableCompositeCodec> augmentableCodecs = new WeakHashMap<>(); + private static final Map, AugmentationCodec> augmentationCodecs = new WeakHashMap<>(); + private static final Map, QName> identityQNames = new WeakHashMap<>(); + private static final Map qnamesToIdentityMap = new ConcurrentHashMap<>(); /** Binding type to encountered classes mapping **/ @SuppressWarnings("rawtypes") - Map> typeToClass = new ConcurrentHashMap<>(); + private static final Map> typeToClass = new ConcurrentHashMap<>(); @SuppressWarnings("rawtypes") - private ConcurrentMap typeToCaseNodes = new ConcurrentHashMap<>(); + private static final ConcurrentMap typeToCaseCodecs = new ConcurrentHashMap<>(); private CaseClassMapFacade classToCaseRawCodec = new CaseClassMapFacade(); - Map pathToType = new ConcurrentHashMap<>(); + private static final Map pathToType = new ConcurrentHashMap<>(); + private static final Map, Type> pathToInstantiatedType = new ConcurrentHashMap<>(); + private static final Map typeToQname = new ConcurrentHashMap<>(); private SchemaContext currentSchema; @@ -109,24 +128,83 @@ public class LazyGeneratedCodecRegistry implements // @Override public > AugmentationCodec getCodecForAugmentation(Class object) { - // TODO Auto-generated method stub - return null; + AugmentationCodec codec = null; + @SuppressWarnings("rawtypes") + AugmentationCodec potentialCodec = augmentationCodecs.get(object); + if (potentialCodec != null) { + codec = potentialCodec; + } else + try { + Class, Object>> augmentRawCodec = generator + .augmentationTransformerFor(object); + BindingCodec, Object> rawCodec = augmentRawCodec.newInstance(); + codec = new AugmentationCodecWrapper(rawCodec); + augmentationCodecs.put(augmentRawCodec, codec); + } catch (InstantiationException e) { + LOG.error("Can not instantiate raw augmentation codec {}", object.getSimpleName(), e); + } catch (IllegalAccessException e) { + LOG.debug("BUG: Constructor for {} is not accessible.", object.getSimpleName(), e); + } + Class> objectSupertype = getAugmentableArgumentFrom(object); + if (objectSupertype != null) { + getAugmentableCodec(objectSupertype).addAugmentationCodec(object, codec); + } else { + LOG.warn("Could not find augmentation target for augmentation {}", object); + } + return codec; + } + + private static Class> getAugmentableArgumentFrom( + final Class> augmentation) { + try { + Class> ret = ClassLoaderUtils.withClassLoader(augmentation.getClassLoader(), + new Callable>>() { + @Override + @SuppressWarnings("unchecked") + public Class> call() throws Exception { + for (java.lang.reflect.Type supertype : augmentation.getGenericInterfaces()) { + if (supertype instanceof ParameterizedType + && Augmentation.class.equals(((ParameterizedType) supertype).getRawType())) { + ParameterizedType augmentationGeneric = (ParameterizedType) supertype; + return (Class>) augmentationGeneric + .getActualTypeArguments()[0]; + } + } + return null; + } + }); + return ret; + } catch (Exception e) { + LOG.debug("Could not find augmentable for {} using {}", augmentation, augmentation.getClassLoader(), e); + return null; + } } @Override public Class getClassForPath(List names) { DataSchemaNode node = getSchemaNode(names); SchemaPath path = node.getPath(); - GeneratedTypeBuilder type = pathToType.get(path); - ReferencedTypeImpl typeref = new ReferencedTypeImpl(type.getPackageName(), type.getName()); + Type type = pathToType.get(path); + if (type != null) { + type = new ReferencedTypeImpl(type.getPackageName(), type.getName()); + } else { + type = pathToInstantiatedType.get(names); + } @SuppressWarnings("rawtypes") - WeakReference weakRef = typeToClass.get(typeref); - if(weakRef == null) { - LOG.error("Could not find loaded class for path: {} and type: {}",path,typeref.getFullyQualifiedName()); + WeakReference weakRef = typeToClass.get(type); + if (weakRef == null) { + LOG.error("Could not find loaded class for path: {} and type: {}", path, type.getFullyQualifiedName()); } return weakRef.get(); } + @Override + public void putPathToClass(List names, Class cls) { + Type reference = Types.typeForClass(cls); + pathToInstantiatedType.put(names, reference); + bindingClassEncountered(cls); + } + @Override public IdentifierCodec getKeyCodecForPath(List names) { @SuppressWarnings("unchecked") @@ -148,30 +226,31 @@ public class LazyGeneratedCodecRegistry implements // return newWrapper; } - @Override @SuppressWarnings("rawtypes") public void bindingClassEncountered(Class cls) { - + ConcreteType typeRef = Types.typeForClass(cls); - if(typeToClass.containsKey(typeRef)) { + if (typeToClass.containsKey(typeRef)) { return; } - LOG.info("Binding Class {} encountered.",cls); + LOG.trace("Binding Class {} encountered.", cls); WeakReference weakRef = new WeakReference<>(cls); typeToClass.put(typeRef, weakRef); - if(DataObject.class.isAssignableFrom(cls)) { - @SuppressWarnings({"unchecked","unused"}) + if (Augmentation.class.isAssignableFrom(cls)) { + + } else if (DataObject.class.isAssignableFrom(cls)) { + @SuppressWarnings({ "unchecked", "unused" }) Object cdc = getCodecForDataObject((Class) cls); } } - + @Override public void onClassProcessed(Class cls) { ConcreteType typeRef = Types.typeForClass(cls); - if(typeToClass.containsKey(typeRef)) { + if (typeToClass.containsKey(typeRef)) { return; } - LOG.info("Binding Class {} encountered.",cls); + LOG.trace("Binding Class {} encountered.", cls); WeakReference weakRef = new WeakReference<>((Class) cls); typeToClass.put(typeRef, weakRef); } @@ -249,9 +328,21 @@ public class LazyGeneratedCodecRegistry implements // return newWrapper; } + @Override + public IdentitityCodec getIdentityCodec() { + return identityRefCodec; + } + + @Override + public IdentitityCodec getCodecForIdentity(Class codec) { + bindingClassEncountered(codec); + return identityRefCodec; + } + @Override public void onCodecCreated(Class cls) { CodecMapping.setIdentifierCodec(cls, instanceIdentifierCodec); + CodecMapping.setIdentityRefCodec(cls, identityRefCodec); } @Override @@ -277,10 +368,12 @@ public class LazyGeneratedCodecRegistry implements // return potential; } ConcreteType typeref = Types.typeForClass(caseClass); - ChoiceCaseCodecImpl caseCodec = typeToCaseNodes.get(typeref); + ChoiceCaseCodecImpl caseCodec = typeToCaseCodecs.get(typeref); + checkState(caseCodec != null, "Case Codec was not created proactivelly for %s", caseClass.getName()); + checkState(caseCodec.getSchema() != null, "Case schema is not available for %s", caseClass.getName()); @SuppressWarnings("unchecked") - Class newCodec = generator.caseCodecFor(caseClass, caseCodec.schema); + Class newCodec = generator.caseCodecFor(caseClass, caseCodec.getSchema()); BindingCodec newInstance = newInstanceOf(newCodec); caseCodec.setDelegate(newInstance); caseCodecs.put(caseClass, caseCodec); @@ -295,7 +388,12 @@ public class LazyGeneratedCodecRegistry implements // public void onModuleContextAdded(SchemaContext schemaContext, Module module, ModuleContext context) { pathToType.putAll(context.getChildNodes()); - + qnamesToIdentityMap.putAll(context.getIdentities()); + for (Entry identity : context.getIdentities().entrySet()) { + typeToQname.put( + new ReferencedTypeImpl(identity.getValue().getPackageName(), identity.getValue().getName()), + identity.getKey()); + } captureCases(context.getCases(), schemaContext); } @@ -303,16 +401,22 @@ public class LazyGeneratedCodecRegistry implements // for (Entry caseNode : cases.entrySet()) { ReferencedTypeImpl typeref = new ReferencedTypeImpl(caseNode.getValue().getPackageName(), caseNode .getValue().getName()); + + pathToType.put(caseNode.getKey(), caseNode.getValue()); + ChoiceCaseNode node = (ChoiceCaseNode) SchemaContextUtil.findDataSchemaNode(module, caseNode.getKey()); + if (node == null) { LOG.error("YANGTools Bug: SchemaNode for {}, with path {} was not found in context.", typeref.getFullyQualifiedName(), caseNode.getKey()); + @SuppressWarnings("rawtypes") + ChoiceCaseCodecImpl value = new ChoiceCaseCodecImpl(); + typeToCaseCodecs.putIfAbsent(typeref, value); continue; } - @SuppressWarnings("rawtypes") ChoiceCaseCodecImpl value = new ChoiceCaseCodecImpl(node); - typeToCaseNodes.putIfAbsent(typeref, value); + typeToCaseCodecs.putIfAbsent(typeref, value); } } @@ -324,7 +428,7 @@ public class LazyGeneratedCodecRegistry implements // @SuppressWarnings({ "unchecked", "rawtypes" }) @Override public void onChoiceCodecCreated(Class choiceClass, - Class, Object>> choiceCodec) { + Class, Object>> choiceCodec, ChoiceNode schema) { ChoiceCodec oldCodec = choiceCodecs.get(choiceClass); checkState(oldCodec == null); BindingCodec, Object> delegate = newInstanceOf(choiceCodec); @@ -333,24 +437,41 @@ public class LazyGeneratedCodecRegistry implements // CodecMapping.setClassToCaseMap(choiceCodec, (Map, BindingCodec>) classToCaseRawCodec); CodecMapping.setCompositeNodeToCaseMap(choiceCodec, newCodec.getCompositeToCase()); + tryToCreateCasesCodecs(schema); + + } + + private void tryToCreateCasesCodecs(ChoiceNode schema) { + for (ChoiceCaseNode caseNode : schema.getCases()) { + SchemaPath path = caseNode.getPath(); + GeneratedTypeBuilder type; + if (path != null && (type = pathToType.get(path)) != null) { + ReferencedTypeImpl typeref = new ReferencedTypeImpl(type.getPackageName(), type.getName()); + ChoiceCaseCodecImpl partialCodec = typeToCaseCodecs.get(typeref); + if (partialCodec.getSchema() == null) { + partialCodec.setSchema(caseNode); + } + + Class caseClass = ClassLoaderUtils.tryToLoadClassWithTCCL(type.getFullyQualifiedName()); + if (caseClass != null) { + getCaseCodecFor(caseClass); + } + } + } + } @Override public void onValueCodecCreated(Class valueClass, Class valueCodec) { - // TODO Auto-generated method stub - } @Override public void onCaseCodecCreated(Class choiceClass, Class, Object>> choiceCodec) { - // TODO Auto-generated method stub - } @Override - public void onDataContainerCodecCreated(Class dataClass, - Class, Object>> dataCodec) { + public void onDataContainerCodecCreated(Class dataClass, Class> dataCodec) { if (Augmentable.class.isAssignableFrom(dataClass)) { AugmentableCompositeCodec augmentableCodec = getAugmentableCodec(dataClass); CodecMapping.setAugmentationCodec(dataCodec, augmentableCodec); @@ -358,7 +479,7 @@ public class LazyGeneratedCodecRegistry implements // } - private AugmentableCompositeCodec getAugmentableCodec(Class dataClass) { + public AugmentableCompositeCodec getAugmentableCodec(Class dataClass) { AugmentableCompositeCodec ret = augmentableCodecs.get(dataClass); if (ret != null) { return ret; @@ -439,15 +560,15 @@ public class LazyGeneratedCodecRegistry implements // @SuppressWarnings("rawtypes") private static class ChoiceCaseCodecImpl implements ChoiceCaseCodec, // Delegator { - private final boolean augmenting; + private boolean augmenting; private BindingCodec delegate; - private final Set validNames; - private final Set validQNames; + private Set validNames; + private Set validQNames; private ChoiceCaseNode schema; - public ChoiceCaseCodecImpl(ChoiceCaseNode caseNode) { - this.delegate = NOT_READY_CODEC; + public void setSchema(ChoiceCaseNode caseNode) { + this.schema = schema; this.schema = caseNode; validNames = new HashSet<>(); validQNames = new HashSet<>(); @@ -459,6 +580,15 @@ public class LazyGeneratedCodecRegistry implements // augmenting = caseNode.isAugmenting(); } + public ChoiceCaseCodecImpl() { + this.delegate = NOT_READY_CODEC; + } + + public ChoiceCaseCodecImpl(ChoiceCaseNode caseNode) { + this.delegate = NOT_READY_CODEC; + setSchema(caseNode); + } + @Override public ValueWithQName deserialize(Node input) { throw new UnsupportedOperationException("Direct invocation of this codec is not allowed."); @@ -483,7 +613,7 @@ public class LazyGeneratedCodecRegistry implements // @Override public boolean isAcceptable(Node input) { - if (false == (input instanceof CompositeNode)) { + if (input instanceof CompositeNode) { if (augmenting) { return checkAugmenting((CompositeNode) input); } else { @@ -497,10 +627,8 @@ public class LazyGeneratedCodecRegistry implements // QName parent = input.getNodeType(); for (Node childNode : input.getChildren()) { QName child = childNode.getNodeType(); - if (false == Objects.equals(parent.getNamespace(), child.getNamespace())) { - continue; - } - if (false == Objects.equals(parent.getRevision(), child.getRevision())) { + if (!Objects.equals(parent.getNamespace(), child.getNamespace()) + || !Objects.equals(parent.getRevision(), child.getRevision())) { continue; } if (validNames.contains(child.getLocalName())) { @@ -563,14 +691,14 @@ public class LazyGeneratedCodecRegistry implements // @Override public Set>> entrySet() { - return null; + return Collections.emptySet(); } @Override public BindingCodec get(Object key) { if (key instanceof Class) { Class cls = (Class) key; - //bindingClassEncountered(cls); + // bindingClassEncountered(cls); ChoiceCaseCodecImpl caseCodec = getCaseCodecFor(cls); return caseCodec.getDelegate(); } @@ -589,7 +717,7 @@ public class LazyGeneratedCodecRegistry implements // @Override public BindingCodec get(Object key) { - if (false == (key instanceof CompositeNode)) { + if (!(key instanceof CompositeNode)) { return null; } for (java.util.Map.Entry> entry : choiceCases.entrySet()) { @@ -600,8 +728,7 @@ public class LazyGeneratedCodecRegistry implements // } return null; } - - + } /** @@ -641,7 +768,7 @@ public class LazyGeneratedCodecRegistry implements // @Override public Collection> values() { - return null; + return Collections.emptySet(); } private UnsupportedOperationException notModifiable() { @@ -649,7 +776,7 @@ public class LazyGeneratedCodecRegistry implements // } @Override - public BindingCodec, Object> put(T key, BindingCodec value) { + public BindingCodec, Object> put(T key, BindingCodec value) { throw notModifiable(); } @@ -665,18 +792,17 @@ public class LazyGeneratedCodecRegistry implements // @Override public boolean isEmpty() { - return false; + return true; } @Override public Set keySet() { - return null; + return Collections.emptySet(); } @Override public Set>> entrySet() { - // TODO Auto-generated method stub - return null; + return Collections.emptySet(); } @Override @@ -690,7 +816,7 @@ public class LazyGeneratedCodecRegistry implements // private final Class augmentableType; - Map rawAugmentationCodecs = new WeakHashMap<>(); + Map> localAugmentationCodecs = new WeakHashMap<>(); public AugmentableCompositeCodec(Class type) { checkArgument(Augmentable.class.isAssignableFrom(type)); @@ -714,14 +840,8 @@ public class LazyGeneratedCodecRegistry implements // augmentationField.setAccessible(true); Map augMap = (Map) augmentationField.get(input); return augMap; - } catch (NoSuchFieldException e) { - - } catch (SecurityException e) { - - } catch (IllegalArgumentException e) { - - } catch (IllegalAccessException e) { - + } catch (IllegalArgumentException | IllegalAccessException | NoSuchFieldException | SecurityException e) { + LOG.debug("Could not read augmentations for {}", input, e); } return Collections.emptyMap(); } @@ -729,53 +849,33 @@ public class LazyGeneratedCodecRegistry implements // private List serializeImpl(Map input) { List ret = new ArrayList<>(); for (Entry entry : input.entrySet()) { - BindingCodec codec = getRawCodecForAugmentation(entry.getKey()); - List output = (List) codec.serialize(new ValueWithQName(null, entry.getValue())); - ret.addAll(output); + AugmentationCodec codec = getCodecForAugmentation(entry.getKey()); + CompositeNode node = codec.serialize(new ValueWithQName(null, entry.getValue())); + ret.addAll(node.getChildren()); } return ret; } - private BindingCodec getRawCodecForAugmentation(Class key) { - BindingCodec ret = rawAugmentationCodecs.get(key); - if (ret != null) { - return ret; - } - try { - Class retClass = generator.augmentationTransformerFor(key); - ret = retClass.newInstance(); - rawAugmentationCodecs.put(key, ret); - return ret; - } catch (InstantiationException e) { - - } catch (IllegalAccessException e) { - - } - return null; + public synchronized > void addAugmentationCodec(Class augmentationClass, + AugmentationCodec value) { + localAugmentationCodecs.put(augmentationClass, value); } @Override public Map deserialize(Object input) { Map ret = new HashMap<>(); if (input instanceof CompositeNode) { - for (Entry codec : rawAugmentationCodecs.entrySet()) { - Augmentation value = (Augmentation) codec.getValue().deserialize(input); - if (value != null) { - ret.put(codec.getKey(), value); + List>> codecs = new ArrayList<>(localAugmentationCodecs.entrySet()); + for (Entry> codec : codecs) { + ValueWithQName value = codec.getValue().deserialize((CompositeNode) input); + if (value != null && value.getValue() != null) { + ret.put(codec.getKey(), (Augmentation) value.getValue()); } } } return ret; } - public Map getRawAugmentationCodecs() { - return rawAugmentationCodecs; - } - - public void setRawAugmentationCodecs(Map rawAugmentationCodecs) { - this.rawAugmentationCodecs = rawAugmentationCodecs; - } - public Class getAugmentableType() { return augmentableType; } @@ -804,4 +904,104 @@ public class LazyGeneratedCodecRegistry implements // return getDelegate().serialize(input); } } + + private static class AugmentationCodecWrapper> implements AugmentationCodec, + Delegator { + + private BindingCodec delegate; + + public AugmentationCodecWrapper(BindingCodec, Object> rawCodec) { + this.delegate = rawCodec; + } + + @Override + public BindingCodec getDelegate() { + return delegate; + } + + @Override + public CompositeNode serialize(ValueWithQName input) { + @SuppressWarnings("unchecked") + List> rawValues = (List>) getDelegate().serialize(input); + List> serialized = new ArrayList<>(rawValues.size()); + for (Map val : rawValues) { + serialized.add(toNode(val)); + } + return new CompositeNodeTOImpl(input.getQname(), null, serialized); + } + + @Override + @SuppressWarnings("unchecked") + public ValueWithQName deserialize(Node input) { + Object rawCodecValue = getDelegate().deserialize((Map) input); + return new ValueWithQName(input.getNodeType(), (T) rawCodecValue); + } + } + + private class IdentityCompositeCodec implements IdentitityCodec { + + @Override + public Object deserialize(Object input) { + checkArgument(input instanceof QName); + return deserialize((QName) input); + } + + @Override + public Class deserialize(QName input) { + Type type = qnamesToIdentityMap.get(input); + if (type == null) { + return null; + } + ReferencedTypeImpl typeref = new ReferencedTypeImpl(type.getPackageName(), type.getName()); + WeakReference softref = typeToClass.get(typeref); + if (softref == null) { + return null; + } + return softref.get(); + } + + @Override + public QName serialize(Class input) { + checkArgument(BaseIdentity.class.isAssignableFrom(input)); + bindingClassEncountered(input); + QName qname = identityQNames.get(input); + if (qname != null) { + return qname; + } + ConcreteType typeref = Types.typeForClass(input); + qname = typeToQname.get(typeref); + if (qname != null) { + identityQNames.put(input, qname); + } + return qname; + } + + @Override + public Object serialize(Object input) { + checkArgument(input instanceof Class); + return serialize((Class) input); + } + } + + public boolean isCodecAvailable(Class cls) { + if (containerCodecs.containsKey(cls)) { + return true; + } + if (identifierCodecs.containsKey(cls)) { + return true; + } + if (choiceCodecs.containsKey(cls)) { + return true; + } + if (caseCodecs.containsKey(cls)) { + return true; + } + if (augmentableCodecs.containsKey(cls)) { + return true; + } + if (augmentationCodecs.containsKey(cls)) { + return true; + } + return false; + } } \ No newline at end of file