import com.google.common.collect.Multimap;
import com.google.common.collect.Multimaps;
-public class LazyGeneratedCodecRegistry implements //
+class LazyGeneratedCodecRegistry implements //
CodecRegistry, //
SchemaContextListener, //
GeneratorListener {
private static final Logger LOG = LoggerFactory.getLogger(LazyGeneratedCodecRegistry.class);
private static final 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 static final Map<Class<?>, DataContainerCodec<?>> containerCodecs = Collections
.synchronizedMap(new WeakHashMap<Class<?>, DataContainerCodec<?>>());
@SuppressWarnings("rawtypes")
private static final ConcurrentMap<Type, ChoiceCaseCodecImpl> typeToCaseCodecs = new ConcurrentHashMap<>();
- private final CaseClassMapFacade classToCaseRawCodec = new CaseClassMapFacade();
-
- private static final Map<SchemaPath, InstanceIdentifier<?>> pathToBindingIdentifier = new ConcurrentHashMap<>();
private static final Map<SchemaPath, GeneratedTypeBuilder> pathToType = new ConcurrentHashMap<>();
private static final Map<List<QName>, Type> pathToInstantiatedType = new ConcurrentHashMap<>();
private static final Map<Type, QName> typeToQname = new ConcurrentHashMap<>();
private static final Multimap<Type, Type> choiceToCases = Multimaps.synchronizedMultimap(HashMultimap
.<Type, Type> create());
+ private final InstanceIdentifierCodec instanceIdentifierCodec = new InstanceIdentifierCodecImpl(this);
+ private final CaseClassMapFacade classToCaseRawCodec = new CaseClassMapFacade();
+ private final IdentityCompositeCodec identityRefCodec = new IdentityCompositeCodec();
+ private final ClassLoadingStrategy classLoadingStrategy;
+ private final AbstractTransformerGenerator generator;
private final SchemaLock lock;
+ // FIXME: how is this protected?
private SchemaContext currentSchema;
- private final ClassLoadingStrategy classLoadingStrategy;
-
- LazyGeneratedCodecRegistry(final SchemaLock lock, final ClassLoadingStrategy identityClassLoadingStrategy) {
+ LazyGeneratedCodecRegistry(final SchemaLock lock, final AbstractTransformerGenerator generator,
+ final ClassLoadingStrategy classLoadingStrategy) {
this.lock = Preconditions.checkNotNull(lock);
- this.classLoadingStrategy = identityClassLoadingStrategy;
+ this.classLoadingStrategy = Preconditions.checkNotNull(classLoadingStrategy);
+ this.generator = Preconditions.checkNotNull(generator);
}
public SchemaLock getLock() {
return lock;
}
- public TransformerGenerator getGenerator() {
- return generator;
- }
-
- public void setGenerator(final TransformerGenerator generator) {
- this.generator = generator;
- }
-
@Override
public InstanceIdentifierCodec getInstanceIdentifierCodec() {
return instanceIdentifierCodec;
bindingClassEncountered(cls);
}
- public InstanceIdentifier<?> getBindingIdentifierByPath(final SchemaPath path) {
- return pathToBindingIdentifier.get(path);
- }
-
- public void putPathToBindingIdentifier(final SchemaPath path, final InstanceIdentifier<?> bindingIdentifier) {
- pathToBindingIdentifier.put(path, bindingIdentifier);
- }
-
- public InstanceIdentifier<?> putPathToBindingIdentifier(final SchemaPath path,
- final InstanceIdentifier<?> bindingIdentifier, final Class<?> childClass) {
- @SuppressWarnings({ "unchecked", "rawtypes" })
- InstanceIdentifier<?> newId = bindingIdentifier.builder().child((Class) childClass).build();
- pathToBindingIdentifier.put(path, newId);
- return newId;
- }
-
@Override
public IdentifierCodec<?> getKeyCodecForPath(final List<QName> names) {
@SuppressWarnings("unchecked")
caseClass.getName());
Preconditions.checkState(caseCodec.getSchema() != null, "Case schema is not available for %s",
caseClass.getName());
- @SuppressWarnings("unchecked")
Class<? extends BindingCodec> newCodec = generator.caseCodecFor(caseClass, caseCodec.getSchema());
BindingCodec newInstance = newInstanceOf(newCodec);
caseCodec.setDelegate(newInstance);
if (adaptedForPaths.contains(path)) {
return;
}
+ /**
+ * We search in schema context if the use of this location aware codec (augmentable codec, case codec)
+ * makes sense on provided location (path)
+ *
+ */
Optional<DataNodeContainer> contextNode = BindingSchemaContextUtils.findDataNodeContainer(currentSchema, path);
+ /**
+ * If context node is present, this codec makes sense on provided location.
+ *
+ */
if (contextNode.isPresent()) {
synchronized (this) {
+ /**
+ *
+ * We adapt (turn on / off) possible implementations of child codecs (augmentations, cases)
+ * based on this location.
+ *
+ *
+ */
adaptForPathImpl(path, contextNode.get());
+ try {
+ /**
+ * We trigger serialization of instance identifier, to make sure instance identifier
+ * codec is aware of combination of this path / augmentation / case
+ */
+ instanceIdentifierCodec.serialize(path);
+ } catch (Exception e) {
+ LOG.warn("Exception during preparation of instance identifier codec for path {}.",path,e);
+ }
adaptedForPaths.add(path);
}
} else {
}
- public boolean isCodecAvailable(final Class<? extends DataContainer> cls) {
+ public boolean isCodecAvailable(final Class<?> cls) {
+ // FIXME: enforce type?
+ // Preconditions.checkArgument(DataContainer.class.isAssignableFrom(cls));
+
if (containerCodecs.containsKey(cls)) {
return true;
}
Code Review / yangtools.git / blobdiff