code-generator/binding-data-codec/src/main/java/org/opendaylight/yangtools/binding/data/codec/impl/ChoiceNodeCodecContext.java

   1 /*
   2  * Copyright (c) 2014 Cisco Systems, Inc. and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8 package org.opendaylight.yangtools.binding.data.codec.impl;
   9
  10 import com.google.common.base.Optional;
  11 import com.google.common.base.Preconditions;
  12 import com.google.common.collect.ImmutableMap;
  13 import com.google.common.collect.Iterables;
  14 import java.util.HashMap;
  15 import java.util.Map;
  16 import org.opendaylight.yangtools.yang.binding.DataObject;
  17 import org.opendaylight.yangtools.yang.binding.util.BindingReflections;
  18 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
  19 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
  20 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
  21 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNodeContainer;
  22 import org.opendaylight.yangtools.yang.model.api.ChoiceCaseNode;
  23 import org.opendaylight.yangtools.yang.model.api.ChoiceNode;
  24 import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
  25 import org.slf4j.Logger;
  26 import org.slf4j.LoggerFactory;
  27
  28 final class ChoiceNodeCodecContext extends DataContainerCodecContext<ChoiceNode> {
  29     private static final Logger LOG = LoggerFactory.getLogger(ChoiceNodeCodecContext.class);
  30     private final ImmutableMap<YangInstanceIdentifier.PathArgument, DataContainerCodecPrototype<?>> byYangCaseChild;
  31     private final ImmutableMap<Class<?>, DataContainerCodecPrototype<?>> byClass;
  32     private final ImmutableMap<Class<?>, DataContainerCodecPrototype<?>> byCaseChildClass;
  33
  34     public ChoiceNodeCodecContext(final DataContainerCodecPrototype<ChoiceNode> prototype) {
  35         super(prototype);
  36         Map<YangInstanceIdentifier.PathArgument, DataContainerCodecPrototype<?>> byYangCaseChildBuilder = new HashMap<>();
  37         Map<Class<?>, DataContainerCodecPrototype<?>> byClassBuilder = new HashMap<>();
  38         Map<Class<?>, DataContainerCodecPrototype<?>> byCaseChildClassBuilder = new HashMap<>();
  39
  40         for (Class<?> caze : factory().getRuntimeContext().getCases(bindingClass())) {
  41             DataContainerCodecPrototype<ChoiceCaseNode> cazeDef = loadCase(caze);
  42             if (cazeDef != null) {
  43                 byClassBuilder.put(cazeDef.getBindingClass(), cazeDef);
  44                 for (Class<? extends DataObject> cazeChild : BindingReflections.getChildrenClasses((Class) caze)) {
  45                     byCaseChildClassBuilder.put(cazeChild, cazeDef);
  46                 }
  47                 for (DataSchemaNode cazeChild : cazeDef.getSchema().getChildNodes()) {
  48                     byYangCaseChildBuilder.put(new NodeIdentifier(cazeChild.getQName()), cazeDef);
  49                 }
  50             }
  51         }
  52
  53         byYangCaseChild = ImmutableMap.copyOf(byYangCaseChildBuilder);
  54         byClass = ImmutableMap.copyOf(byClassBuilder);
  55         byCaseChildClass = ImmutableMap.copyOf(byCaseChildClassBuilder);
  56     }
  57
  58     @Override
  59     protected DataContainerCodecContext<?> getStreamChild(final Class<?> childClass) {
  60         DataContainerCodecPrototype<?> child = byClass.get(childClass);
  61         Preconditions.checkArgument(child != null,"Supplied class is not valid case",childClass);
  62         return child.get();
  63     }
  64
  65     @Override
  66     protected Optional<DataContainerCodecContext<?>> getPossibleStreamChild(final Class<?> childClass) {
  67         DataContainerCodecPrototype<?> child = byClass.get(childClass);
  68         if(child != null) {
  69             return Optional.<DataContainerCodecContext<?>>of(child.get());
  70         }
  71         return Optional.absent();
  72     }
  73
  74     Iterable<Class<?>> getCaseChildrenClasses() {
  75         return byCaseChildClass.keySet();
  76     }
  77
  78     protected DataContainerCodecPrototype<ChoiceCaseNode> loadCase(final Class<?> childClass) {
  79         Optional<ChoiceCaseNode> childSchema = factory().getRuntimeContext().getCaseSchemaDefinition(schema(), childClass);
  80         if (childSchema.isPresent()) {
  81             return DataContainerCodecPrototype.from(childClass, childSchema.get(), factory());
  82         }
  83
  84         LOG.debug("Supplied class %s is not valid case in schema %s", childClass, schema());
  85         return null;
  86     }
  87
  88     @Override
  89     protected NodeCodecContext getYangIdentifierChild(final YangInstanceIdentifier.PathArgument arg) {
  90         DataContainerCodecPrototype<?> cazeProto = byYangCaseChild.get(arg);
  91         Preconditions.checkArgument(cazeProto != null, "Argument %s is not valid child of %s", arg, schema());
  92         return cazeProto.get().getYangIdentifierChild(arg);
  93     }
  94
  95     @Override
  96     protected Object dataFromNormalizedNode(final NormalizedNode<?, ?> data) {
  97         Preconditions
  98                 .checkArgument(data instanceof org.opendaylight.yangtools.yang.data.api.schema.ChoiceNode);
  99         NormalizedNodeContainer<?, ?, NormalizedNode<?,?>> casted = (NormalizedNodeContainer<?, ?, NormalizedNode<?,?>>) data;
 100         NormalizedNode<?, ?> first = Iterables.getFirst(casted.getValue(), null);
 101
 102         if (first == null) {
 103             return null;
 104         }
 105         DataContainerCodecPrototype<?> caze = byYangCaseChild.get(first.getIdentifier());
 106         return caze.get().dataFromNormalizedNode(data);
 107     }
 108
 109     public DataContainerCodecContext<?> getCazeByChildClass(final Class<? extends DataObject> type) {
 110         return byCaseChildClass.get(type).get();
 111     }
 112
 113 }