}
- private class IdentifiableItemCodec implements Codec<NodeIdentifierWithPredicates, IdentifiableItem<?, ?>> {
+ private static class IdentifiableItemCodec implements Codec<NodeIdentifierWithPredicates, IdentifiableItem<?, ?>> {
private final ImmutableSortedMap<QName, ValueContext> keyValueContexts;
private final ListSchemaNode schema;
import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableSortedMap;
import java.lang.reflect.Method;
import java.util.Collection;
+import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
+import java.util.SortedMap;
+import java.util.TreeMap;
import org.opendaylight.yangtools.sal.binding.generator.api.ClassLoadingStrategy;
import org.opendaylight.yangtools.sal.binding.model.api.Type;
import org.opendaylight.yangtools.yang.binding.Augmentable;
abstract class DataObjectCodecContext<T extends DataNodeContainer> extends DataContainerCodecContext<T> {
private static final Logger LOG = LoggerFactory.getLogger(DataObjectCodecContext.class);
+ private static final Comparator<Method> METHOD_BY_ALPHABET = new Comparator<Method>() {
+
+ @Override
+ public int compare(final Method o1, final Method o2) {
+ return o1.getName().compareTo(o2.getName());
+ }
+ };
+
private final ImmutableMap<String, LeafNodeCodecContext> leafChild;
private final ImmutableMap<YangInstanceIdentifier.PathArgument, NodeContextSupplier> byYang;
- private final ImmutableMap<Method, NodeContextSupplier> byMethod;
+ private final ImmutableSortedMap<Method, NodeContextSupplier> byMethod;
private final ImmutableMap<Class<?>, DataContainerCodecPrototype<?>> byStreamClass;
private final ImmutableMap<Class<?>, DataContainerCodecPrototype<?>> byBindingArgClass;
protected final Method augmentationGetter;
Map<Class<?>, Method> clsToMethod = BindingReflections.getChildrenClassToMethod(bindingClass());
Map<YangInstanceIdentifier.PathArgument, NodeContextSupplier> byYangBuilder = new HashMap<>();
- Map<Method, NodeContextSupplier> byMethodBuilder = new HashMap<>();
+ SortedMap<Method, NodeContextSupplier> byMethodBuilder = new TreeMap<>(METHOD_BY_ALPHABET);
Map<Class<?>, DataContainerCodecPrototype<?>> byStreamClassBuilder = new HashMap<>();
Map<Class<?>, DataContainerCodecPrototype<?>> byBindingArgClassBuilder = new HashMap<>();
}
}
}
- this.byMethod = ImmutableMap.copyOf(byMethodBuilder);
+ this.byMethod = ImmutableSortedMap.copyOfSorted(byMethodBuilder);
if (Augmentable.class.isAssignableFrom(bindingClass())) {
try {
augmentationGetter = bindingClass().getMethod("getAugmentation", Class.class);
return byMethod.keySet();
}
-}
\ No newline at end of file
+}
* Name of Enclosing Type
* @return <code>new</code> Instance of Generated Type Builder.
*/
- GeneratedTOBuilder addEnclosingTransferObject(final String name);
+ GeneratedTOBuilder addEnclosingTransferObject(String name);
/**
* Adds new Enclosing Transfer Object <code>genTOBuilder</code> into
* @param genTOBuilder
* Name of Enclosing Type
*/
- T addEnclosingTransferObject(final GeneratedTOBuilder genTOBuilder);
+ T addEnclosingTransferObject(GeneratedTOBuilder genTOBuilder);
/**
* Adds String definition of comment into Method Signature definition. <br>
* @param comment
* Comment String.
*/
- T addComment(final String comment);
+ T addComment(String comment);
/**
* The method creates new AnnotationTypeBuilder containing specified package
* Name of Annotation Type
* @return <code>new</code> instance of Annotation Type Builder.
*/
- AnnotationTypeBuilder addAnnotation(final String packageName, final String name);
+ AnnotationTypeBuilder addAnnotation(String packageName, String name);
boolean isAbstract();
* Type to implement
* @return <code>true</code> if the addition of type is successful.
*/
- T addImplementsType(final Type genType);
+ T addImplementsType(Type genType);
/**
* Adds Constant definition and returns <code>new</code> Constant instance. <br>
* Assigned Value
* @return <code>new</code> Constant instance.
*/
- Constant addConstant(final Type type, final String name, final Object value);
+ Constant addConstant(Type type, String name, Object value);
/**
* Adds new Enumeration definition for Generated Type Builder and returns
* Enumeration Name
* @return <code>new</code> instance of Enumeration Builder.
*/
- EnumBuilder addEnumeration(final String name);
+ EnumBuilder addEnumeration(String name);
List<MethodSignatureBuilder> getMethodDefinitions();
* Name of Method
* @return <code>new</code> instance of Method Signature Builder.
*/
- MethodSignatureBuilder addMethod(final String name);
+ MethodSignatureBuilder addMethod(String name);
/**
* Checks if GeneratedTypeBuilder contains method with name
* @param methodName
* is method name
*/
- boolean containsMethod(final String methodName);
+ boolean containsMethod(String methodName);
List<GeneratedPropertyBuilder> getProperties();
* Name of Property
* @return <code>new</code> instance of Generated Property Builder.
*/
- GeneratedPropertyBuilder addProperty(final String name);
+ GeneratedPropertyBuilder addProperty(String name);
/**
* Check whether GeneratedTOBuilder contains property with name
* of property which existance is checked
* @return true if property <code>name</code> exists in list of properties.
*/
- boolean containsProperty(final String name);
+ boolean containsProperty(String name);
/**
* Set a string that contains a human-readable textual description of type
}
typeDefinitionsConcreteDepth.add(unsortedTypeDefinition);
}
- // keys are in ascending order
- for (Map.Entry<Integer, List<TypeDefinition<?>>> entry : typeDefinitionsDepths.entrySet()) {
- sortedTypeDefinition.addAll(entry.getValue());
+
+ // SortedMap guarantees order corresponding to keys in ascending order
+ for (List<TypeDefinition<?>> v : typeDefinitionsDepths.values()) {
+ sortedTypeDefinition.addAll(v);
}
return sortedTypeDefinition;
terms of the Eclipse Public License v1.0 which accompanies this distribution,
and is available at http://www.eclipse.org/legal/epl-v10.html
-->
-<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
- xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
- <modelVersion>4.0.0</modelVersion>
- <parent>
- <groupId>org.opendaylight.yangtools</groupId>
- <artifactId>yangtools-parent</artifactId>
- <version>0.6.2-SNAPSHOT</version>
- <relativePath>../parent/pom.xml</relativePath>
- </parent>
- <artifactId>features-yangtools</artifactId>
- <packaging>jar</packaging>
- <properties>
- <features.file>features.xml</features.file>
- </properties>
- <build>
- <resources>
- <resource>
- <directory>src/main/resources</directory>
- <filtering>true</filtering>
- </resource>
- </resources>
- <plugins>
- <plugin>
- <groupId>org.apache.karaf.tooling</groupId>
- <artifactId>karaf-maven-plugin</artifactId>
- <version>${karaf.version}</version>
- <extensions>true</extensions>
- <executions>
- <execution>
- <id>features-create-kar</id>
- <goals>
- <goal>features-create-kar</goal>
- </goals>
- <configuration>
- <featuresFile>${project.build.directory}/classes/${features.file}</featuresFile>
- </configuration>
- </execution>
- </executions>
- <!-- There is no useful configuration for the kar mojo. The features-generate-descriptor mojo configuration may be useful -->
- </plugin>
- <plugin>
- <groupId>org.apache.maven.plugins</groupId>
- <artifactId>maven-resources-plugin</artifactId>
- <executions>
- <execution>
- <id>filter</id>
- <phase>generate-resources</phase>
- <goals>
- <goal>resources</goal>
- </goals>
- </execution>
- </executions>
- </plugin>
- <plugin>
- <groupId>org.codehaus.mojo</groupId>
- <artifactId>build-helper-maven-plugin</artifactId>
- <executions>
- <execution>
- <id>attach-artifacts</id>
- <phase>package</phase>
- <goals>
- <goal>attach-artifact</goal>
- </goals>
- <configuration>
- <artifacts>
- <artifact>
- <file>${project.build.directory}/classes/${features.file}</file>
- <type>xml</type>
- <classifier>features</classifier>
- </artifact>
- </artifacts>
- </configuration>
- </execution>
- </executions>
- </plugin>
- <plugin>
- <groupId>org.apache.maven.plugins</groupId>
- <artifactId>maven-surefire-plugin</artifactId>
- <configuration>
- <dependenciesToScan>
- <dependency>org.opendaylight.yangtools:features-test</dependency>
- </dependenciesToScan>
- </configuration>
- </plugin>
- </plugins>
- </build>
- <dependencies>
- <dependency>
- <groupId>org.opendaylight.yangtools.model</groupId>
- <artifactId>ietf-inet-types</artifactId>
- </dependency>
- <dependency>
- <groupId>org.opendaylight.yangtools.model</groupId>
- <artifactId>ietf-yang-types</artifactId>
- </dependency>
- <dependency>
- <groupId>org.opendaylight.yangtools.model</groupId>
- <artifactId>ietf-yang-types-20130715</artifactId>
- </dependency>
- <dependency>
- <groupId>org.opendaylight.yangtools.model</groupId>
- <artifactId>yang-ext</artifactId>
- </dependency>
- <dependency>
- <groupId>org.opendaylight.yangtools.model</groupId>
- <artifactId>opendaylight-l2-types</artifactId>
- </dependency>
- <dependency>
- <groupId>org.opendaylight.yangtools.model</groupId>
- <artifactId>ietf-topology</artifactId>
- </dependency>
- <dependency>
- <groupId>org.opendaylight.yangtools.thirdparty</groupId>
- <artifactId>antlr4-runtime-osgi-nohead</artifactId>
- <scope>compile</scope>
- </dependency>
- <dependency>
- <groupId>org.opendaylight.yangtools</groupId>
- <artifactId>yang-data-api</artifactId>
- </dependency>
- <dependency>
- <groupId>org.opendaylight.yangtools</groupId>
- <artifactId>yang-data-composite-node</artifactId>
- </dependency>
- <dependency>
- <groupId>org.opendaylight.yangtools</groupId>
- <artifactId>yang-data-impl</artifactId>
- </dependency>
- <dependency>
- <groupId>org.opendaylight.yangtools</groupId>
- <artifactId>yang-data-operations</artifactId>
- </dependency>
- <dependency>
- <groupId>org.opendaylight.yangtools</groupId>
- <artifactId>yang-data-util</artifactId>
- </dependency>
- <dependency>
- <groupId>org.opendaylight.yangtools</groupId>
- <artifactId>yang-model-api</artifactId>
- </dependency>
- <dependency>
- <groupId>org.opendaylight.yangtools</groupId>
- <artifactId>yang-model-util</artifactId>
- </dependency>
- <dependency>
- <groupId>org.opendaylight.yangtools</groupId>
- <artifactId>yang-parser-impl</artifactId>
- </dependency>
- <dependency>
- <groupId>org.opendaylight.yangtools</groupId>
- <artifactId>yang-parser-api</artifactId>
- </dependency>
- <dependency>
- <groupId>org.opendaylight.yangtools</groupId>
- <artifactId>yang-binding</artifactId>
- </dependency>
- <dependency>
- <groupId>org.opendaylight.yangtools</groupId>
- <artifactId>util</artifactId>
- </dependency>
- <dependency>
- <groupId>org.opendaylight.yangtools</groupId>
- <artifactId>concepts</artifactId>
- </dependency>
- <dependency>
- <groupId>org.opendaylight.yangtools</groupId>
- <artifactId>yang-common</artifactId>
- </dependency>
- <dependency>
- <groupId>org.opendaylight.yangtools</groupId>
- <artifactId>util</artifactId>
- </dependency>
- <dependency>
- <groupId>org.opendaylight.yangtools</groupId>
- <artifactId>object-cache-api</artifactId>
- </dependency>
- <dependency>
- <groupId>org.opendaylight.yangtools</groupId>
- <artifactId>object-cache-guava</artifactId>
- </dependency>
- <dependency>
- <groupId>org.opendaylight.yangtools</groupId>
- <artifactId>object-cache-noop</artifactId>
- </dependency>
- <dependency>
- <groupId>org.opendaylight.yangtools</groupId>
- <artifactId>binding-generator-api</artifactId>
- </dependency>
- <dependency>
- <groupId>org.opendaylight.yangtools</groupId>
- <artifactId>binding-generator-impl</artifactId>
- </dependency>
- <dependency>
- <groupId>org.opendaylight.yangtools</groupId>
- <artifactId>binding-generator-spi</artifactId>
- </dependency>
- <dependency>
- <groupId>org.opendaylight.yangtools</groupId>
- <artifactId>binding-generator-util</artifactId>
- </dependency>
- <dependency>
- <groupId>org.opendaylight.yangtools</groupId>
- <artifactId>binding-model-api</artifactId>
- </dependency>
- <dependency>
- <groupId>org.opendaylight.yangtools</groupId>
- <artifactId>binding-type-provider</artifactId>
- </dependency>
- <dependency>
- <groupId>org.opendaylight.yangtools</groupId>
- <artifactId>yang-model-api</artifactId>
- </dependency>
- <dependency>
- <groupId>org.opendaylight.yangtools</groupId>
- <artifactId>yang-model-util</artifactId>
- </dependency>
- <dependency>
- <groupId>org.opendaylight.yangtools</groupId>
- <artifactId>yang-parser-api</artifactId>
- </dependency>
- <dependency>
- <groupId>org.opendaylight.yangtools</groupId>
- <artifactId>restconf-client-api</artifactId>
- </dependency>
- <dependency>
- <groupId>org.opendaylight.yangtools</groupId>
- <artifactId>restconf-client-impl</artifactId>
- </dependency>
- <dependency>
- <groupId>org.opendaylight.yangtools</groupId>
- <artifactId>restconf-common</artifactId>
- </dependency>
- <dependency>
- <groupId>org.opendaylight.yangtools</groupId>
- <artifactId>binding-data-codec</artifactId>
- </dependency>
- <dependency>
- <groupId>org.opendaylight.yangtools.thirdparty</groupId>
- <artifactId>xtend-lib-osgi</artifactId>
- <scope>compile</scope>
- </dependency>
- <!-- test the features.xml -->
- <dependency>
- <groupId>org.opendaylight.yangtools</groupId>
- <artifactId>features-test</artifactId>
- <scope>test</scope>
- </dependency>
- </dependencies>
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+ <modelVersion>4.0.0</modelVersion>
+ <parent>
+ <groupId>org.opendaylight.yangtools</groupId>
+ <artifactId>yangtools-parent</artifactId>
+ <version>0.6.2-SNAPSHOT</version>
+ <relativePath>../parent/pom.xml</relativePath>
+ </parent>
+ <artifactId>features-yangtools</artifactId>
+ <packaging>jar</packaging>
+ <properties>
+ <features.file>features.xml</features.file>
+ </properties>
+ <build>
+ <resources>
+ <resource>
+ <directory>src/main/resources</directory>
+ <filtering>true</filtering>
+ </resource>
+ </resources>
+ <plugins>
+ <plugin>
+ <groupId>org.apache.karaf.tooling</groupId>
+ <artifactId>karaf-maven-plugin</artifactId>
+ <version>${karaf.version}</version>
+ <extensions>true</extensions>
+ <executions>
+ <execution>
+ <id>features-create-kar</id>
+ <goals>
+ <goal>features-create-kar</goal>
+ </goals>
+ <configuration>
+ <featuresFile>${project.build.directory}/classes/${features.file}</featuresFile>
+ </configuration>
+ </execution>
+ </executions>
+ <!-- There is no useful configuration for the kar mojo. The features-generate-descriptor mojo configuration may be useful -->
+ </plugin>
+ <plugin>
+ <groupId>org.apache.maven.plugins</groupId>
+ <artifactId>maven-resources-plugin</artifactId>
+ <executions>
+ <execution>
+ <id>filter</id>
+ <phase>generate-resources</phase>
+ <goals>
+ <goal>resources</goal>
+ </goals>
+ </execution>
+ </executions>
+ </plugin>
+ <plugin>
+ <groupId>org.codehaus.mojo</groupId>
+ <artifactId>build-helper-maven-plugin</artifactId>
+ <executions>
+ <execution>
+ <id>attach-artifacts</id>
+ <phase>package</phase>
+ <goals>
+ <goal>attach-artifact</goal>
+ </goals>
+ <configuration>
+ <artifacts>
+ <artifact>
+ <file>${project.build.directory}/classes/${features.file}</file>
+ <type>xml</type>
+ <classifier>features</classifier>
+ </artifact>
+ </artifacts>
+ </configuration>
+ </execution>
+ </executions>
+ </plugin>
+ <plugin>
+ <groupId>org.apache.maven.plugins</groupId>
+ <artifactId>maven-surefire-plugin</artifactId>
+ <configuration>
+ <dependenciesToScan>
+ <dependency>org.opendaylight.yangtools:features-test</dependency>
+ </dependenciesToScan>
+ </configuration>
+ </plugin>
+ </plugins>
+ </build>
+ <dependencies>
+ <dependency>
+ <groupId>org.opendaylight.yangtools.model</groupId>
+ <artifactId>ietf-inet-types</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.yangtools.model</groupId>
+ <artifactId>ietf-yang-types</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.yangtools.model</groupId>
+ <artifactId>ietf-yang-types-20130715</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.yangtools.model</groupId>
+ <artifactId>yang-ext</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.yangtools.model</groupId>
+ <artifactId>opendaylight-l2-types</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.yangtools.model</groupId>
+ <artifactId>ietf-topology</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.yangtools.thirdparty</groupId>
+ <artifactId>antlr4-runtime-osgi-nohead</artifactId>
+ <scope>compile</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.yangtools</groupId>
+ <artifactId>yang-data-api</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.yangtools</groupId>
+ <artifactId>yang-data-composite-node</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.yangtools</groupId>
+ <artifactId>yang-data-impl</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.yangtools</groupId>
+ <artifactId>yang-data-operations</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.yangtools</groupId>
+ <artifactId>yang-data-util</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.yangtools</groupId>
+ <artifactId>yang-data-codec-gson</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.yangtools</groupId>
+ <artifactId>yang-model-api</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.yangtools</groupId>
+ <artifactId>yang-model-util</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.yangtools</groupId>
+ <artifactId>yang-parser-impl</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.yangtools</groupId>
+ <artifactId>yang-parser-api</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.yangtools</groupId>
+ <artifactId>yang-binding</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.yangtools</groupId>
+ <artifactId>util</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.yangtools</groupId>
+ <artifactId>concepts</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.yangtools</groupId>
+ <artifactId>yang-common</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.yangtools</groupId>
+ <artifactId>util</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.yangtools</groupId>
+ <artifactId>object-cache-api</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.yangtools</groupId>
+ <artifactId>object-cache-guava</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.yangtools</groupId>
+ <artifactId>object-cache-noop</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.yangtools</groupId>
+ <artifactId>binding-generator-api</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.yangtools</groupId>
+ <artifactId>binding-generator-impl</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.yangtools</groupId>
+ <artifactId>binding-generator-spi</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.yangtools</groupId>
+ <artifactId>binding-generator-util</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.yangtools</groupId>
+ <artifactId>binding-model-api</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.yangtools</groupId>
+ <artifactId>binding-type-provider</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.yangtools</groupId>
+ <artifactId>yang-model-api</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.yangtools</groupId>
+ <artifactId>yang-model-util</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.yangtools</groupId>
+ <artifactId>yang-parser-api</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.yangtools</groupId>
+ <artifactId>restconf-client-api</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.yangtools</groupId>
+ <artifactId>restconf-client-impl</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.yangtools</groupId>
+ <artifactId>restconf-common</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.yangtools</groupId>
+ <artifactId>binding-data-codec</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.yangtools.thirdparty</groupId>
+ <artifactId>xtend-lib-osgi</artifactId>
+ <scope>compile</scope>
+ </dependency>
+ <dependency>
+ <groupId>com.google.code.gson</groupId>
+ <artifactId>gson</artifactId>
+ </dependency>
+
+ <!-- test the features.xml -->
+ <dependency>
+ <groupId>org.opendaylight.yangtools</groupId>
+ <artifactId>features-test</artifactId>
+ <scope>test</scope>
+ </dependency>
+ </dependencies>
</project>
<bundle>mvn:org.opendaylight.yangtools.thirdparty/antlr4-runtime-osgi-nohead/${antlr4.version}</bundle>
<bundle>mvn:commons-io/commons-io/${commons.io.version}</bundle>
<bundle>mvn:org.opendaylight.yangtools/yang-data-api/${project.version}</bundle>
+ <bundle>mvn:org.opendaylight.yangtools/yang-data-composite-node/${project.version}</bundle>
<bundle>mvn:org.opendaylight.yangtools/yang-data-impl/${project.version}</bundle>
<bundle>mvn:org.opendaylight.yangtools/yang-data-operations/${project.version}</bundle>
- <bundle>mvn:org.opendaylight.yangtools/yang-data-composite-node/${project.version}</bundle>
<bundle>mvn:org.opendaylight.yangtools/yang-data-util/${project.version}</bundle>
<bundle>mvn:org.opendaylight.yangtools/yang-model-api/${project.version}</bundle>
<bundle>mvn:org.opendaylight.yangtools/yang-model-util/${project.version}</bundle>
- <bundle>mvn:org.opendaylight.yangtools/yang-parser-impl/${project.version}</bundle>
<bundle>mvn:org.opendaylight.yangtools/yang-parser-api/${project.version}</bundle>
+ <bundle>mvn:org.opendaylight.yangtools/yang-parser-impl/${project.version}</bundle>
+
+ <!-- GSON-based JSON codec. Can be split out -->
+ <bundle>mvn:com.google.code.gson/gson/${gson.version}</bundle>
+ <bundle>mvn:org.opendaylight.yangtools/yang-data-codec-gson/${project.version}</bundle>
</feature>
<feature name='odl-yangtools-binding' version='${project.version}' description='OpenDaylight :: Yangtools :: Binding'>
*/
package org.opendaylight.yangtools.objcache;
+import com.google.common.base.Preconditions;
+
import javax.annotation.Nonnull;
+import javax.annotation.concurrent.GuardedBy;
import org.opendaylight.yangtools.objcache.impl.StaticObjectCacheBinder;
import org.opendaylight.yangtools.objcache.spi.IObjectCacheFactory;
import org.opendaylight.yangtools.objcache.spi.NoopObjectCacheBinder;
-import com.google.common.base.Preconditions;
-
/**
* Point of entry for acquiring an {@link ObjectCache} instance.
*/
public final class ObjectCacheFactory {
- private static IObjectCacheFactory FACTORY;
+ private static volatile IObjectCacheFactory factory;
+ @GuardedBy("this")
private static synchronized IObjectCacheFactory initialize() {
// Double-check under lock
- if (FACTORY != null) {
- return FACTORY;
+ IObjectCacheFactory f = factory;
+ if (f != null) {
+ return f;
}
- IObjectCacheFactory f;
try {
f = StaticObjectCacheBinder.getInstance().getProductCacheFactory();
- FACTORY = f;
+ factory = f;
} catch (NoClassDefFoundError e) {
f = NoopObjectCacheBinder.INSTANCE.getProductCacheFactory();
}
}
public static synchronized void reset() {
- FACTORY = null;
+ factory = null;
}
/**
* @return Object cache instance.
*/
public static ObjectCache getObjectCache(@Nonnull final Class<?> objClass) {
- IObjectCacheFactory f = FACTORY;
+ IObjectCacheFactory f = factory;
if (f == null) {
f = initialize();
}
<artifactId>yang-data-impl</artifactId>
<version>0.6.2-SNAPSHOT</version>
</dependency>
+ <dependency>
+ <groupId>org.opendaylight.yangtools</groupId>
+ <artifactId>yang-data-codec-gson</artifactId>
+ <version>0.6.2-SNAPSHOT</version>
+ </dependency>
<dependency>
<groupId>org.opendaylight.yangtools</groupId>
<artifactId>yang-model-api</artifactId>
<version>${sonar-jacoco-listeners.version}</version>
<scope>test</scope>
</dependency>
+ <dependency>
+ <groupId>org.slf4j</groupId>
+ <artifactId>slf4j-simple</artifactId>
+ <scope>test</scope>
+ </dependency>
</dependencies>
<build>
<repository>
<id>opendaylight-mirror</id>
<name>opendaylight-mirror</name>
- <url>http://nexus.opendaylight.org/content/groups/public/</url>
+ <url>${nexusproxy}/groups/public/</url>
<snapshots>
<enabled>false</enabled>
</snapshots>
<repository>
<id>opendaylight-snapshot</id>
<name>opendaylight-snapshot</name>
- <url>http://nexus.opendaylight.org/content/repositories/opendaylight.snapshot/</url>
+ <url>${nexusproxy}/repositories/opendaylight.snapshot/</url>
<snapshots>
<enabled>true</enabled>
</snapshots>
}
try {
this.listenerCallbackMethod.invoke(message);
- } catch (IllegalAccessException e) {
- throw new IllegalStateException(e.getMessage());
- } catch (InvocationTargetException e) {
- throw new IllegalStateException(e.getMessage());
+ } catch (IllegalAccessException | InvocationTargetException e) {
+ throw new IllegalStateException("Failed to invoke callback", e);
}
}
restModule.setName(eElement.getElementsByTagName("name").item(0).getTextContent());
restModule.setNamespace(eElement.getElementsByTagName("namespace").item(0).getTextContent());
restModule.setRevision(eElement.getElementsByTagName("revision").item(0).getTextContent());
- } catch (NullPointerException npe){
- throw new IllegalStateException("Incomplete module data in xml.");
+ } catch (NullPointerException e) {
+ throw new IllegalStateException("Incomplete module data in xml.", e);
}
return restModule;
}
import com.google.common.base.CharMatcher;
import com.google.common.base.Splitter;
import com.google.common.collect.ImmutableSet;
+
import java.text.SimpleDateFormat;
import java.util.Set;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
+
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
throw new UnsupportedOperationException("Utility class should not be instantiated");
}
- public static final String getRootPackageName(final QName module) {
+ public static String getRootPackageName(final QName module) {
return getRootPackageName(module.getModule());
}
- public static final String getRootPackageName(final QNameModule module) {
+ public static String getRootPackageName(final QNameModule module) {
checkArgument(module != null, "Module must not be null");
checkArgument(module.getRevision() != null, "Revision must not be null");
checkArgument(module.getNamespace() != null, "Namespace must not be null");
return builder.toString();
}
- public static final String getMethodName(final QName name) {
+ public static String getMethodName(final QName name) {
checkArgument(name != null, "Name should not be null.");
return getMethodName(name.getLocalName());
}
- public static final String getClassName(final String localName) {
+ public static String getClassName(final String localName) {
checkArgument(localName != null, "Name should not be null.");
return toFirstUpper(toCamelCase(localName));
}
- public static final String getMethodName(final String yangIdentifier) {
+ public static String getMethodName(final String yangIdentifier) {
checkArgument(yangIdentifier != null,"Identifier should not be null");
return toFirstLower(toCamelCase(yangIdentifier));
}
- public static final String getClassName(final QName name) {
+ public static String getClassName(final QName name) {
checkArgument(name != null, "Name should not be null.");
return toFirstUpper(toCamelCase(name.getLocalName()));
}
return potential;
}
- private static final String toCamelCase(final String rawString) {
+ private static String toCamelCase(final String rawString) {
checkArgument(rawString != null, "String should not be null");
Iterable<String> components = CAMEL_SPLITTER.split(rawString);
StringBuilder builder = new StringBuilder();
return checkNumericPrefix(builder.toString());
}
- private static final String checkNumericPrefix(final String rawString) {
+ private static String checkNumericPrefix(final String rawString) {
if (rawString == null || rawString.isEmpty()) {
return rawString;
}
@Deprecated
public interface NodeModificationBuilder {
- abstract Node<?> getMutableEquivalent(Node<?> originalNode);
+ Node<?> getMutableEquivalent(Node<?> originalNode);
- abstract CompositeNode buildDiffTree();
+ CompositeNode buildDiffTree();
- abstract void mergeNode(MutableCompositeNode alteredNode);
+ void mergeNode(MutableCompositeNode alteredNode);
- abstract void removeNode(MutableCompositeNode deadNode);
+ void removeNode(MutableCompositeNode deadNode);
- abstract void removeNode(MutableSimpleNode<?> deadNode);
+ void removeNode(MutableSimpleNode<?> deadNode);
- abstract void deleteNode(MutableSimpleNode<?> deadNode);
+ void deleteNode(MutableSimpleNode<?> deadNode);
- abstract void deleteNode(MutableCompositeNode deadNode);
+ void deleteNode(MutableCompositeNode deadNode);
- abstract void replaceNode(MutableCompositeNode replacementNode);
+ void replaceNode(MutableCompositeNode replacementNode);
- abstract void replaceNode(MutableSimpleNode<?> replacementNode);
+ void replaceNode(MutableSimpleNode<?> replacementNode);
- abstract void addNode(MutableCompositeNode newNode);
+ void addNode(MutableCompositeNode newNode);
- abstract void addNode(MutableSimpleNode<?> newNode);
+ void addNode(MutableSimpleNode<?> newNode);
}
package org.opendaylight.yangtools.yang.data.api.schema.stream;
import com.google.common.annotations.Beta;
-import com.google.common.base.Preconditions;
import com.google.common.base.Strings;
-import java.io.IOException;
+import java.util.ArrayDeque;
+import java.util.Deque;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
+/**
+ * A {@link NormalizedNodeStreamWriter} which logs the events into a {@link Logger}.
+ */
@Beta
-public class LoggingNormalizedNodeStreamWriter implements NormalizedNodeStreamWriter {
+public final class LoggingNormalizedNodeStreamWriter implements NormalizedNodeStreamWriter {
private static final Logger LOG = LoggerFactory.getLogger(LoggingNormalizedNodeStreamWriter.class);
private static final int DEFAULT_INDENT_SIZE = 2;
- private final int indentSize = DEFAULT_INDENT_SIZE;
- private int currentIndent = 0;
+
+ private final Deque<String> indent = new ArrayDeque<>();
+ private final String indentStr;
+
+ public LoggingNormalizedNodeStreamWriter() {
+ this(DEFAULT_INDENT_SIZE);
+ }
+
+ public LoggingNormalizedNodeStreamWriter(final int indentSize) {
+ this.indentStr = Strings.repeat(" ", indentSize);
+ indent.push("");
+ }
private String ind() {
- return Strings.repeat(" ", currentIndent);
+ return indent.peek();
}
private void decIndent() {
- Preconditions.checkState(currentIndent >= 0, "Unexpected indentation %s", currentIndent);
- currentIndent -= indentSize;
+ indent.pop();
}
private void incIndent() {
- currentIndent += indentSize;
+ indent.push(ind() + indentStr);
}
@Override
- public void startUnkeyedListItem(final NodeIdentifier name, final int childSizeHint) throws IllegalStateException {
+ public void startUnkeyedListItem(final NodeIdentifier name, final int childSizeHint) {
LOG.debug("{}{}[](no key)", ind(), name);
incIndent();
}
@Override
- public void startUnkeyedList(final NodeIdentifier name, final int childSizeHint) throws IllegalArgumentException {
+ public void startUnkeyedList(final NodeIdentifier name, final int childSizeHint) {
LOG.debug("{}{}(no key)", ind(), name);
incIndent();
}
@Override
- public void startOrderedMapNode(final NodeIdentifier name, final int childSizeHint) throws IllegalArgumentException {
+ public void startOrderedMapNode(final NodeIdentifier name, final int childSizeHint) {
}
@Override
- public void startMapNode(final NodeIdentifier name, final int childSizeHint) throws IllegalArgumentException {
+ public void startMapNode(final NodeIdentifier name, final int childSizeHint) {
LOG.debug("{}{}(key)", ind(), name);
incIndent();
}
@Override
- public void startMapEntryNode(final NodeIdentifierWithPredicates identifier, final int childSizeHint)
- throws IllegalArgumentException {
+ public void startMapEntryNode(final NodeIdentifierWithPredicates identifier, final int childSizeHint) {
LOG.debug("{}{}[](key)", ind(), identifier);
incIndent();
}
@Override
- public void startLeafSet(final NodeIdentifier name, final int childSizeHint) throws IllegalArgumentException {
+ public void startLeafSet(final NodeIdentifier name, final int childSizeHint) {
LOG.debug("{}{}(leaf-list)", ind(), name);
incIndent();
}
@Override
- public void startContainerNode(final NodeIdentifier name, final int childSizeHint) throws IllegalArgumentException {
+ public void startContainerNode(final NodeIdentifier name, final int childSizeHint) {
LOG.debug("{}{}(container)", ind(), name);
incIndent();
}
@Override
- public void startChoiceNode(final NodeIdentifier name, final int childSizeHint) throws IllegalArgumentException {
+ public void startChoiceNode(final NodeIdentifier name, final int childSizeHint) {
LOG.debug("{}{}(choice)", ind(), name);
incIndent();
}
@Override
- public void startAugmentationNode(final AugmentationIdentifier identifier) throws IllegalArgumentException {
+ public void startAugmentationNode(final AugmentationIdentifier identifier) {
LOG.debug("{}{}(augmentation)", ind(), identifier);
incIndent();
}
@Override
- public void leafSetEntryNode(final Object value) throws IllegalArgumentException {
+ public void leafSetEntryNode(final Object value) {
LOG.debug("{}{}({}) ", ind(), value, value.getClass().getSimpleName());
}
@Override
- public void leafNode(final NodeIdentifier name, final Object value) throws IllegalArgumentException {
+ public void leafNode(final NodeIdentifier name, final Object value) {
LOG.debug("{}{}(leaf({}))=", ind(), name, value.getClass().getSimpleName(), value);
}
}
@Override
- public void anyxmlNode(final NodeIdentifier name, final Object value) throws IllegalArgumentException {
+ public void anyxmlNode(final NodeIdentifier name, final Object value) {
LOG.debug("{}{}(anyxml)=", ind(), name, value);
}
@Override
- public void flush() throws IOException {
+ public void flush() {
LOG.trace("<<FLUSH>>");
}
@Override
- public void close() throws IOException {
+ public void close() {
LOG.debug("<<END-OF-STREAM>>");
}
}
\ No newline at end of file
import java.io.Flushable;
import java.io.IOException;
+import javax.xml.stream.XMLStreamReader;
+
import org.opendaylight.yangtools.yang.data.api.schema.AnyXmlNode;
import org.opendaylight.yangtools.yang.data.api.schema.AugmentationNode;
import org.opendaylight.yangtools.yang.data.api.schema.ChoiceNode;
import org.opendaylight.yangtools.yang.data.api.schema.UnkeyedListNode;
/**
- * This is an experimental
+ * This is an experimental iterator over a {@link NormalizedNode}. This is essentially
+ * the opposite of a {@link XMLStreamReader} -- unlike instantiating an iterator over
+ * the backing data, this encapsulates a {@link NormalizedNodeStreamWriter} and allows
+ * us to write multiple nodes.
*/
@Beta
public final class NormalizedNodeWriter implements Closeable, Flushable {
this.writer = Preconditions.checkNotNull(writer);
}
+ /**
+ * Create a new writer backed by a {@link NormalizedNodeStreamWriter}.
+ *
+ * @param writer Backend writer
+ * @return A new instance.
+ */
public static NormalizedNodeWriter forStreamWriter(final NormalizedNodeStreamWriter writer) {
return new NormalizedNodeWriter(writer);
}
+ /**
+ * Iterate over the provided {@link NormalizedNode} and emit write
+ * events to the encapsulated {@link NormalizedNodeStreamWriter}.
+ *
+ * @param node Node
+ * @return
+ * @throws IOException when thrown from the backing writer.
+ */
public NormalizedNodeWriter write(final NormalizedNode<?, ?> node) throws IOException {
if (wasProcessedAsCompositeNode(node)) {
return this;
<groupId>org.opendaylight.yangtools</groupId>
<artifactId>yang-data-impl</artifactId>
</dependency>
+ <dependency>
+ <groupId>org.opendaylight.yangtools</groupId>
+ <artifactId>yang-data-util</artifactId>
+ </dependency>
<dependency>
<groupId>org.opendaylight.yangtools</groupId>
<artifactId>yang-parser-impl</artifactId>
*/
package org.opendaylight.yangtools.yang.data.codec.gson;
+import com.google.common.annotations.Beta;
+import com.google.common.base.Preconditions;
+
import java.io.IOException;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
+/**
+ * Utility abstract class for tracking parser state, as needed by StAX-like parser.
+ */
+@Beta
abstract class AbstractNodeDataWithSchema {
-
private final DataSchemaNode schema;
- public AbstractNodeDataWithSchema(final DataSchemaNode schema) {
- this.schema = schema;
+ protected AbstractNodeDataWithSchema(final DataSchemaNode schema) {
+ this.schema = Preconditions.checkNotNull(schema);
}
+ /**
+ * Return the associated schema node.
+ * @return
+ */
public final DataSchemaNode getSchema() {
return schema;
}
- protected abstract void writeToStream(final NormalizedNodeStreamWriter nnStreamWriter) throws IOException;
+ /**
+ * Emit this node's events into the specified writer.
+ *
+ * @param writer Target writer
+ * @throws IOException reported when thrown by the writer.
+ */
+ public abstract void write(final NormalizedNodeStreamWriter writer) throws IOException;
- protected NodeIdentifier provideNodeIdentifier() {
+ protected final NodeIdentifier provideNodeIdentifier() {
return new NodeIdentifier(schema.getQName());
}
if (getClass() != obj.getClass()) {
return false;
}
- AbstractNodeDataWithSchema other = (AbstractNodeDataWithSchema) obj;
- if (schema == null) {
- if (other.schema != null) {
- return false;
- }
- } else if (!schema.equals(other.schema)) {
- return false;
- }
-
- return true;
+ final AbstractNodeDataWithSchema other = (AbstractNodeDataWithSchema) obj;
+ return schema.equals(other.schema);
}
}
}
@Override
- protected void writeToStream(final NormalizedNodeStreamWriter nnStreamWriter) throws IOException {
-// FIXME: should be changed according to format of value
- nnStreamWriter.anyxmlNode(provideNodeIdentifier(), getValue());
+ public void write(final NormalizedNodeStreamWriter writer) throws IOException {
+ // FIXME: should be changed according to format of value
+ writer.anyxmlNode(provideNodeIdentifier(), getValue());
}
}
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
package org.opendaylight.yangtools.yang.data.codec.gson;
-
-import java.io.IOException;
-
-import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter;
import org.opendaylight.yangtools.yang.model.api.ChoiceCaseNode;
class CaseNodeDataWithSchema extends CompositeNodeDataWithSchema {
super(schema);
}
- @Override
- protected void writeToStream(final NormalizedNodeStreamWriter nnStreamWriter) throws IOException {
- super.writeToStream(nnStreamWriter);
- }
}
*/
package org.opendaylight.yangtools.yang.data.codec.gson;
-import static org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter.UNKNOWN_SIZE;
-
import java.io.IOException;
import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter;
}
@Override
- public CompositeNodeDataWithSchema addCompositeChild(final DataSchemaNode schema) {
+ protected CompositeNodeDataWithSchema addCompositeChild(final DataSchemaNode schema) {
CaseNodeDataWithSchema newChild = new CaseNodeDataWithSchema((ChoiceCaseNode) schema);
caseNodeDataWithSchema = newChild;
addCompositeChild(newChild);
}
@Override
- protected void writeToStream(final NormalizedNodeStreamWriter nnStreamWriter) throws IOException {
- nnStreamWriter.startChoiceNode(provideNodeIdentifier(), UNKNOWN_SIZE);
- super.writeToStream(nnStreamWriter);
- nnStreamWriter.endNode();
+ public void write(final NormalizedNodeStreamWriter writer) throws IOException {
+ writer.startChoiceNode(provideNodeIdentifier(), childSizeHint());
+ super.write(writer);
+ writer.endNode();
}
}
--- /dev/null
+/*
+ * Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.data.codec.gson;
+
+import com.google.common.annotations.Beta;
+import com.google.common.cache.CacheBuilder;
+import com.google.common.cache.CacheLoader;
+import com.google.common.cache.LoadingCache;
+
+import org.opendaylight.yangtools.concepts.Codec;
+import org.opendaylight.yangtools.yang.data.api.codec.LeafrefCodec;
+import org.opendaylight.yangtools.yang.data.impl.codec.TypeDefinitionAwareCodec;
+import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
+import org.opendaylight.yangtools.yang.model.api.type.LeafrefTypeDefinition;
+import org.opendaylight.yangtools.yang.model.util.IdentityrefType;
+import org.opendaylight.yangtools.yang.model.util.InstanceIdentifierType;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * This class is implementation-internal and subject to change. Please do not use it.
+ */
+@Beta
+final class CodecFactory {
+ private static final Logger LOG = LoggerFactory.getLogger(CodecFactory.class);
+ private static final Codec<?, ?> LEAFREF_DEFAULT_CODEC = new LeafrefCodec<String>() {
+ @Override
+ public String serialize(final Object data) {
+ return String.valueOf(data);
+ }
+
+ @Override
+ public Object deserialize(final String data) {
+ return data;
+ }
+ };
+ private static final Codec<?, ?> NULL_CODEC = new Codec<Object, Object>() {
+ @Override
+ public Object deserialize(final Object input) {
+ return null;
+ }
+
+ @Override
+ public Object serialize(final Object input) {
+ return null;
+ }
+ };
+
+
+ private static TypeDefinition<?> resolveBaseTypeFrom(final TypeDefinition<?> type) {
+ TypeDefinition<?> superType = type;
+ while (superType.getBaseType() != null) {
+ superType = superType.getBaseType();
+ }
+ return superType;
+ }
+
+ private final LoadingCache<TypeDefinition<?>, Codec<?, ?>> codecs =
+ CacheBuilder.newBuilder().softValues().build(new CacheLoader<TypeDefinition<?>, Codec<?, ?>>() {
+ @Override
+ public Codec<?, ?> load(final TypeDefinition<?> key) throws Exception {
+ final TypeDefinition<?> type = resolveBaseTypeFrom(key);
+
+ if (type instanceof InstanceIdentifierType) {
+ return iidCodec;
+ }
+ if (type instanceof IdentityrefType) {
+ return idrefCodec;
+ }
+ if (type instanceof LeafrefTypeDefinition) {
+ return LEAFREF_DEFAULT_CODEC;
+ }
+
+ final TypeDefinitionAwareCodec<Object, ? extends TypeDefinition<?>> codec = TypeDefinitionAwareCodec.from(type);
+ if (codec == null) {
+ LOG.debug("Codec for type \"{}\" is not implemented yet.", type.getQName().getLocalName());
+ return NULL_CODEC;
+ }
+
+ return codec;
+ }
+ });
+
+ private final Codec<?, ?> iidCodec;
+ private final Codec<?, ?> idrefCodec;
+
+ private CodecFactory(final SchemaContext context) {
+ iidCodec = new JSONStringInstanceIdentifierCodec(context);
+ idrefCodec = new JSONStringIdentityrefCodec(context);
+ }
+
+ public static CodecFactory create(final SchemaContext context) {
+ return new CodecFactory(context);
+ }
+
+ @SuppressWarnings("unchecked")
+ public final Codec<Object, Object> codecFor(final TypeDefinition<?> typeDefinition) {
+ return (Codec<Object, Object>) codecs.getUnchecked(typeDefinition);
+ }
+}
*/
package org.opendaylight.yangtools.yang.data.codec.gson;
+import com.google.common.base.Function;
+import com.google.common.base.Preconditions;
+import com.google.common.collect.ArrayListMultimap;
+import com.google.common.collect.Collections2;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Multimap;
+
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collection;
-import java.util.Collections;
import java.util.Deque;
-import java.util.HashMap;
-import java.util.HashSet;
import java.util.List;
-import java.util.Map;
import java.util.Map.Entry;
-import java.util.Set;
+
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
+/**
+ * A node which is composed of multiple simpler nodes.
+ */
class CompositeNodeDataWithSchema extends AbstractNodeDataWithSchema {
+ private static final Function<DataSchemaNode, QName> QNAME_FUNCTION = new Function<DataSchemaNode, QName>() {
+ @Override
+ public QName apply(@Nonnull final DataSchemaNode input) {
+ return input.getQName();
+ }
+ };
/**
* nodes which were added to schema via augmentation and are present in data input
*/
- protected Map<AugmentationSchema, List<AbstractNodeDataWithSchema>> augmentationsToChild = new HashMap<>();
+ private final Multimap<AugmentationSchema, AbstractNodeDataWithSchema> augmentationsToChild = ArrayListMultimap.create();
/**
- * remaining data nodes (which aren't added via augment). Every of them should have the same QName
+ * remaining data nodes (which aren't added via augment). Every of one them should have the same QName.
*/
- protected List<AbstractNodeDataWithSchema> childs = new ArrayList<>();
+ private final List<AbstractNodeDataWithSchema> children = new ArrayList<>();
public CompositeNodeDataWithSchema(final DataSchemaNode schema) {
super(schema);
}
- public AbstractNodeDataWithSchema addSimpleChild(final DataSchemaNode schema) {
- SimpleNodeDataWithSchema newChild = null;
- if (schema instanceof LeafSchemaNode) {
- newChild = new LeafNodeDataWithSchema(schema);
- } else if (schema instanceof AnyXmlSchemaNode) {
- newChild = new AnyXmlNodeDataWithSchema(schema);
+ public AbstractNodeDataWithSchema addChild(final Deque<DataSchemaNode> schemas) {
+ Preconditions.checkArgument(!schemas.isEmpty(), "Expecting at least one schema");
+
+ // Pop the first node...
+ final DataSchemaNode schema = schemas.pop();
+ if (schemas.isEmpty()) {
+ // Simple, direct node
+ return addChild(schema);
}
- if (newChild != null) {
+ // The choice/case mess, reuse what we already popped
+ final DataSchemaNode choiceCandidate = schema;
+ Preconditions.checkArgument(choiceCandidate instanceof ChoiceNode,
+ "Expected node of type ChoiceNode but was %s", choiceCandidate.getClass().getSimpleName());
+ final ChoiceNode choiceNode = (ChoiceNode) choiceCandidate;
- AugmentationSchema augSchema = null;
- if (schema.isAugmenting()) {
- augSchema = findCorrespondingAugment(getSchema(), schema);
- }
- if (augSchema != null) {
- addChildToAugmentation(augSchema, newChild);
- } else {
- addChild(newChild);
- }
- return newChild;
- }
- return null;
- }
+ final DataSchemaNode caseCandidate = schemas.pop();
+ Preconditions.checkArgument(caseCandidate instanceof ChoiceCaseNode,
+ "Expected node of type ChoiceCaseNode but was %s", caseCandidate.getClass().getSimpleName());
+ final ChoiceCaseNode caseNode = (ChoiceCaseNode) caseCandidate;
- private void addChildToAugmentation(final AugmentationSchema augSchema, final AbstractNodeDataWithSchema newChild) {
- List<AbstractNodeDataWithSchema> childsInAugment = augmentationsToChild.get(augSchema);
- if (childsInAugment == null) {
- childsInAugment = new ArrayList<>();
- augmentationsToChild.put(augSchema, childsInAugment);
+ AugmentationSchema augSchema = null;
+ if (choiceCandidate.isAugmenting()) {
+ augSchema = findCorrespondingAugment(getSchema(), choiceCandidate);
}
- childsInAugment.add(newChild);
- }
- public AbstractNodeDataWithSchema addChild(final Deque<DataSchemaNode> schemas) {
- if (schemas.size() == 1) {
- final DataSchemaNode childDataSchemaNode = schemas.pop();
- return addChild(childDataSchemaNode);
+ // looking for existing choice
+ final Collection<AbstractNodeDataWithSchema> childNodes;
+ if (augSchema != null) {
+ childNodes = augmentationsToChild.get(augSchema);
} else {
- DataSchemaNode choiceCandidate = schemas.pop();
- DataSchemaNode caseCandidate = schemas.pop();
- ChoiceNode choiceNode = null;
- ChoiceCaseNode caseNode = null;
- if (choiceCandidate instanceof ChoiceNode) {
- choiceNode = (ChoiceNode) choiceCandidate;
- } else {
- throw new IllegalArgumentException("Awaited node of type ChoiceNode but was "
- + choiceCandidate.getClass().getSimpleName());
- }
-
- if (caseCandidate instanceof ChoiceCaseNode) {
- caseNode = (ChoiceCaseNode) caseCandidate;
- } else {
- throw new IllegalArgumentException("Awaited node of type ChoiceCaseNode but was "
- + caseCandidate.getClass().getSimpleName());
- }
-
- AugmentationSchema augSchema = null;
- if (choiceCandidate.isAugmenting()) {
- augSchema = findCorrespondingAugment(getSchema(), choiceCandidate);
- }
+ childNodes = children;
+ }
- // looking for existing choice
- List<AbstractNodeDataWithSchema> childNodes = Collections.emptyList();
- if (augSchema != null) {
- childNodes = augmentationsToChild.get(augSchema);
- } else {
- childNodes = childs;
- }
+ CompositeNodeDataWithSchema caseNodeDataWithSchema = findChoice(childNodes, choiceCandidate, caseCandidate);
+ if (caseNodeDataWithSchema == null) {
+ ChoiceNodeDataWithSchema choiceNodeDataWithSchema = new ChoiceNodeDataWithSchema(choiceNode);
+ addChild(choiceNodeDataWithSchema);
+ caseNodeDataWithSchema = choiceNodeDataWithSchema.addCompositeChild(caseNode);
+ }
- CompositeNodeDataWithSchema caseNodeDataWithSchema = findChoice(childNodes, choiceCandidate, caseCandidate);
- if (caseNodeDataWithSchema == null) {
- ChoiceNodeDataWithSchema choiceNodeDataWithSchema = new ChoiceNodeDataWithSchema(choiceNode);
- addChild(choiceNodeDataWithSchema);
- caseNodeDataWithSchema = choiceNodeDataWithSchema.addCompositeChild(caseNode);
- }
+ return caseNodeDataWithSchema.addChild(schemas);
+ }
- return caseNodeDataWithSchema.addChild(schemas);
+ private AbstractNodeDataWithSchema addSimpleChild(final DataSchemaNode schema) {
+ SimpleNodeDataWithSchema newChild = null;
+ if (schema instanceof LeafSchemaNode) {
+ newChild = new LeafNodeDataWithSchema(schema);
+ } else if (schema instanceof AnyXmlSchemaNode) {
+ newChild = new AnyXmlNodeDataWithSchema(schema);
+ } else {
+ return null;
}
+ AugmentationSchema augSchema = null;
+ if (schema.isAugmenting()) {
+ augSchema = findCorrespondingAugment(getSchema(), schema);
+ }
+ if (augSchema != null) {
+ augmentationsToChild.put(augSchema, newChild);
+ } else {
+ addChild(newChild);
+ }
+ return newChild;
}
- private CaseNodeDataWithSchema findChoice(final List<AbstractNodeDataWithSchema> childNodes, final DataSchemaNode choiceCandidate,
+ private CaseNodeDataWithSchema findChoice(final Collection<AbstractNodeDataWithSchema> childNodes, final DataSchemaNode choiceCandidate,
final DataSchemaNode caseCandidate) {
- if (childNodes == null) {
- return null;
- }
- for (AbstractNodeDataWithSchema nodeDataWithSchema : childNodes) {
- if (nodeDataWithSchema instanceof ChoiceNodeDataWithSchema
- && nodeDataWithSchema.getSchema().getQName().equals(choiceCandidate.getQName())) {
- CaseNodeDataWithSchema casePrevious = ((ChoiceNodeDataWithSchema) nodeDataWithSchema).getCase();
- if (casePrevious.getSchema().getQName() != caseCandidate.getQName()) {
- throw new IllegalArgumentException("Data from case " + caseCandidate.getQName()
- + " are specified but other data from case " + casePrevious.getSchema().getQName()
- + " were specified erlier. Data aren't from the same case.");
+ if (childNodes != null) {
+ for (AbstractNodeDataWithSchema nodeDataWithSchema : childNodes) {
+ if (nodeDataWithSchema instanceof ChoiceNodeDataWithSchema
+ && nodeDataWithSchema.getSchema().getQName().equals(choiceCandidate.getQName())) {
+ CaseNodeDataWithSchema casePrevious = ((ChoiceNodeDataWithSchema) nodeDataWithSchema).getCase();
+
+ Preconditions.checkArgument(casePrevious.getSchema().getQName().equals(caseCandidate.getQName()),
+ "Data from case %s are specified but other data from case %s were specified erlier. Data aren't from the same case.",
+ caseCandidate.getQName(), casePrevious.getSchema().getQName());
+
+ return casePrevious;
}
- return casePrevious;
}
}
return null;
}
- public AbstractNodeDataWithSchema addCompositeChild(final DataSchemaNode schema) {
+ AbstractNodeDataWithSchema addCompositeChild(final DataSchemaNode schema) {
CompositeNodeDataWithSchema newChild;
if (schema instanceof ListSchemaNode) {
newChild = new ListNodeDataWithSchema(schema);
return newChild;
}
- public void addCompositeChild(final CompositeNodeDataWithSchema newChild) {
+ void addCompositeChild(final CompositeNodeDataWithSchema newChild) {
AugmentationSchema augSchema = findCorrespondingAugment(getSchema(), newChild.getSchema());
if (augSchema != null) {
- addChildToAugmentation(augSchema, newChild);
+ augmentationsToChild.put(augSchema, newChild);
} else {
addChild(newChild);
}
}
public void addChild(final AbstractNodeDataWithSchema newChild) {
- childs.add(newChild);
+ children.add(newChild);
+ }
+
+ /**
+ * Return a hint about how may children we are going to generate.
+ * @return Size of currently-present node list.
+ */
+ protected final int childSizeHint() {
+ return children.size();
}
/**
* Tries to find in {@code parent} which is dealed as augmentation target node with QName as {@code child}. If such
* node is found then it is returned, else null.
*/
- protected AugmentationSchema findCorrespondingAugment(final DataSchemaNode parent, final DataSchemaNode child) {
+ AugmentationSchema findCorrespondingAugment(final DataSchemaNode parent, final DataSchemaNode child) {
if (parent instanceof AugmentationTarget) {
for (AugmentationSchema augmentation : ((AugmentationTarget) parent).getAvailableAugmentations()) {
DataSchemaNode childInAugmentation = augmentation.getDataChildByName(child.getQName());
}
@Override
- protected void writeToStream(final NormalizedNodeStreamWriter nnStreamWriter) throws IOException {
- for (AbstractNodeDataWithSchema child : childs) {
- child.writeToStream(nnStreamWriter);
+ public void write(final NormalizedNodeStreamWriter writer) throws IOException {
+ for (AbstractNodeDataWithSchema child : children) {
+ child.write(writer);
}
- for (Entry<AugmentationSchema, List<AbstractNodeDataWithSchema>> augmentationToChild : augmentationsToChild.entrySet()) {
-
- final List<AbstractNodeDataWithSchema> childsFromAgumentation = augmentationToChild.getValue();
-
+ for (Entry<AugmentationSchema, Collection<AbstractNodeDataWithSchema>> augmentationToChild : augmentationsToChild.asMap().entrySet()) {
+ final Collection<AbstractNodeDataWithSchema> childsFromAgumentation = augmentationToChild.getValue();
if (!childsFromAgumentation.isEmpty()) {
- nnStreamWriter.startAugmentationNode(toAugmentationIdentifier(augmentationToChild));
+ writer.startAugmentationNode(toAugmentationIdentifier(augmentationToChild.getKey()));
for (AbstractNodeDataWithSchema nodeDataWithSchema : childsFromAgumentation) {
- nodeDataWithSchema.writeToStream(nnStreamWriter);
+ nodeDataWithSchema.write(writer);
}
- nnStreamWriter.endNode();
+ writer.endNode();
}
}
}
- private static AugmentationIdentifier toAugmentationIdentifier(
- final Entry<AugmentationSchema, List<AbstractNodeDataWithSchema>> augmentationToChild) {
- Collection<DataSchemaNode> nodes = augmentationToChild.getKey().getChildNodes();
- Set<QName> nodesQNames = new HashSet<>();
- for (DataSchemaNode node : nodes) {
- nodesQNames.add(node.getQName());
- }
-
- return new AugmentationIdentifier(nodesQNames);
+ private static AugmentationIdentifier toAugmentationIdentifier(final AugmentationSchema schema) {
+ final Collection<QName> qnames = Collections2.transform(schema.getChildNodes(), QNAME_FUNCTION);
+ return new AugmentationIdentifier(ImmutableSet.copyOf(qnames));
}
-
}
*/
package org.opendaylight.yangtools.yang.data.codec.gson;
-import static org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter.UNKNOWN_SIZE;
-
import java.io.IOException;
import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter;
}
@Override
- protected void writeToStream(final NormalizedNodeStreamWriter nnStreamWriter) throws IOException {
- nnStreamWriter.startContainerNode(provideNodeIdentifier(), UNKNOWN_SIZE);
- super.writeToStream(nnStreamWriter);
- nnStreamWriter.endNode();
+ public void write(final NormalizedNodeStreamWriter writer) throws IOException {
+ writer.startContainerNode(provideNodeIdentifier(), childSizeHint());
+ super.write(writer);
+ writer.endNode();
}
}
import java.util.ArrayDeque;
import java.util.Deque;
+import org.opendaylight.yangtools.concepts.Codec;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter;
+import org.opendaylight.yangtools.yang.data.impl.codec.SchemaTracker;
+import org.opendaylight.yangtools.yang.model.api.AnyXmlSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
private final Deque<TypeInfo> stack = new ArrayDeque<>();
private final SchemaContext schemaContext;
+ private final CodecFactory codecs;
+ private final SchemaTracker tracker;
private final Writer writer;
private final String indent;
this.writer = Preconditions.checkNotNull(writer);
Preconditions.checkArgument(indentSize >= 0, "Indent size must be non-negative");
-
if (indentSize != 0) {
indent = Strings.repeat(" ", indentSize);
} else {
indent = null;
}
+
+ this.codecs = CodecFactory.create(schemaContext);
+ this.tracker = SchemaTracker.create(schemaContext);
}
/**
@Override
public void leafNode(final NodeIdentifier name, final Object value) throws IOException {
+ final LeafSchemaNode schema = tracker.leafNode(name);
+ final Codec<Object, Object> codec = codecs.codecFor(schema.getType());
+
separateElementFromPreviousElement();
writeJsonIdentifier(name);
currentNamespace = stack.peek().getNamespace();
- writeValue(value.toString());
+ writeValue(String.valueOf(codec.serialize(value)));
separateNextSiblingsWithComma();
}
@Override
public void startLeafSet(final NodeIdentifier name, final int childSizeHint) throws IOException {
+ tracker.startLeafSet(name);
+
separateElementFromPreviousElement();
stack.push(new TypeInfo(NodeType.LIST, name.getNodeType().getNamespace()));
writeJsonIdentifier(name);
@Override
public void leafSetEntryNode(final Object value) throws IOException {
+ final LeafListSchemaNode schema = tracker.leafSetEntryNode();
+ final Codec<Object, Object> codec = codecs.codecFor(schema.getType());
+
separateElementFromPreviousElement();
- writeValue(value.toString());
+ writeValue(String.valueOf(codec.serialize(value)));
separateNextSiblingsWithComma();
}
@Override
public void startContainerNode(final NodeIdentifier name, final int childSizeHint) throws IOException {
+ tracker.startContainerNode(name);
+
separateElementFromPreviousElement();
stack.push(new TypeInfo(NodeType.OBJECT, name.getNodeType().getNamespace()));
writeJsonIdentifier(name);
@Override
public void startUnkeyedList(final NodeIdentifier name, final int childSizeHint) throws IOException {
+ tracker.startList(name);
+
separateElementFromPreviousElement();
stack.push(new TypeInfo(NodeType.LIST, name.getNodeType().getNamespace()));
writeJsonIdentifier(name);
@Override
public void startUnkeyedListItem(final NodeIdentifier name, final int childSizeHint) throws IOException {
+ tracker.startListItem(name);
+
stack.push(new TypeInfo(NodeType.OBJECT, name.getNodeType().getNamespace()));
separateElementFromPreviousElement();
writeStartObject();
@Override
public void startMapNode(final NodeIdentifier name, final int childSizeHint) throws IOException {
+ tracker.startList(name);
+
separateElementFromPreviousElement();
stack.push(new TypeInfo(NodeType.LIST, name.getNodeType().getNamespace()));
writeJsonIdentifier(name);
@Override
public void startMapEntryNode(final NodeIdentifierWithPredicates identifier, final int childSizeHint)
throws IOException {
+ tracker.startListItem(identifier);
+
stack.push(new TypeInfo(NodeType.OBJECT, identifier.getNodeType().getNamespace()));
separateElementFromPreviousElement();
writeStartObject();
@Override
public void startOrderedMapNode(final NodeIdentifier name, final int childSizeHint) throws IOException {
+ tracker.startListItem(name);
+
stack.push(new TypeInfo(NodeType.LIST, name.getNodeType().getNamespace()));
separateElementFromPreviousElement();
writeJsonIdentifier(name);
@Override
public void startChoiceNode(final NodeIdentifier name, final int childSizeHint) throws IllegalArgumentException {
+ tracker.startChoiceNode(name);
handleInvisibleNode(name.getNodeType().getNamespace());
}
@Override
public void startAugmentationNode(final AugmentationIdentifier identifier) throws IllegalArgumentException {
+ tracker.startAugmentationNode(identifier);
handleInvisibleNode(currentNamespace);
}
@Override
public void anyxmlNode(final NodeIdentifier name, final Object value) throws IOException {
+ final AnyXmlSchemaNode schema = tracker.anyxmlNode(name);
+ // FIXME: should have a codec based on this :)
+
separateElementFromPreviousElement();
writeJsonIdentifier(name);
currentNamespace = stack.peek().getNamespace();
@Override
public void endNode() throws IOException {
- switch (stack.peek().getType()) {
+ tracker.endNode();
+
+ final TypeInfo t = stack.pop();
+ switch (t.getType()) {
case LIST:
indentLeft();
newLine();
default:
break;
}
- stack.pop();
+
currentNamespace = stack.isEmpty() ? null : stack.peek().getNamespace();
separateNextSiblingsWithComma();
}
--- /dev/null
+/*
+ * Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.data.codec.gson;
+
+import com.google.common.base.Preconditions;
+
+import java.net.URI;
+
+import org.opendaylight.yangtools.yang.data.util.AbstractModuleStringIdentityrefCodec;
+import org.opendaylight.yangtools.yang.model.api.Module;
+import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+
+final class JSONStringIdentityrefCodec extends AbstractModuleStringIdentityrefCodec {
+ private final SchemaContext context;
+
+ JSONStringIdentityrefCodec(final SchemaContext context) {
+ this.context = Preconditions.checkNotNull(context);
+ }
+
+ @Override
+ protected Module moduleForPrefix(final String prefix) {
+ return context.findModuleByName(prefix, null);
+ }
+
+ @Override
+ protected String prefixForNamespace(final URI namespace) {
+ final Module module = context.findModuleByNamespaceAndRevision(namespace, null);
+ return module == null ? null : module.getName();
+ }
+
+}
--- /dev/null
+/*
+ * Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.data.codec.gson;
+
+import com.google.common.base.Preconditions;
+
+import java.net.URI;
+
+import org.opendaylight.yangtools.yang.data.util.AbstractModuleStringInstanceIdentifierCodec;
+import org.opendaylight.yangtools.yang.model.api.Module;
+import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+
+final class JSONStringInstanceIdentifierCodec extends AbstractModuleStringInstanceIdentifierCodec {
+ private final SchemaContext context;
+
+ JSONStringInstanceIdentifierCodec(final SchemaContext context) {
+ this.context = Preconditions.checkNotNull(context);
+ }
+
+ @Override
+ protected Module moduleForPrefix(final String prefix) {
+ return context.findModuleByName(prefix, null);
+ }
+
+ @Override
+ protected String prefixForNamespace(final URI namespace) {
+ final Module module = context.findModuleByNamespaceAndRevision(namespace, null);
+ return module == null ? null : module.getName();
+ }
+}
import com.google.common.annotations.Beta;
import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
-import com.google.common.base.Splitter;
-import com.google.common.collect.Iterators;
import com.google.gson.JsonIOException;
import com.google.gson.JsonParseException;
import com.google.gson.JsonSyntaxException;
import com.google.gson.stream.JsonReader;
-import com.google.gson.stream.JsonToken;
import com.google.gson.stream.MalformedJsonException;
import java.io.Closeable;
import java.io.Flushable;
import java.io.IOException;
import java.net.URI;
-import java.security.InvalidParameterException;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Deque;
import java.util.HashSet;
-import java.util.Iterator;
import java.util.List;
import java.util.Set;
-import org.opendaylight.yangtools.concepts.Codec;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter;
-import org.opendaylight.yangtools.yang.data.codec.gson.helpers.IdentityValuesDTO;
-import org.opendaylight.yangtools.yang.data.codec.gson.helpers.RestCodecFactory;
-import org.opendaylight.yangtools.yang.data.codec.gson.helpers.RestUtil;
-import org.opendaylight.yangtools.yang.data.codec.gson.helpers.RestUtil.PrefixMapingFromJson;
-import org.opendaylight.yangtools.yang.data.codec.gson.helpers.SchemaContextUtils;
import org.opendaylight.yangtools.yang.model.api.AnyXmlSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ChoiceCaseNode;
import org.opendaylight.yangtools.yang.model.api.ChoiceNode;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode;
import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
-import org.opendaylight.yangtools.yang.model.api.type.IdentityrefTypeDefinition;
-import org.opendaylight.yangtools.yang.model.api.type.InstanceIdentifierTypeDefinition;
/**
* This class parses JSON elements from a GSON JsonReader. It disallows multiple elements of the same name unlike the
*/
@Beta
public final class JsonParserStream implements Closeable, Flushable {
- private static final Splitter COLON_SPLITTER = Splitter.on(':');
-
private final Deque<URI> namespaces = new ArrayDeque<>();
private final NormalizedNodeStreamWriter writer;
- private final SchemaContextUtils utils;
- private final RestCodecFactory codecs;
+ private final CodecFactory codecs;
private final SchemaContext schema;
private JsonParserStream(final NormalizedNodeStreamWriter writer, final SchemaContext schemaContext) {
this.schema = Preconditions.checkNotNull(schemaContext);
- this.utils = SchemaContextUtils.create(schemaContext);
this.writer = Preconditions.checkNotNull(writer);
- this.codecs = RestCodecFactory.create(utils);
+ this.codecs = CodecFactory.create(schemaContext);
}
public static JsonParserStream create(final NormalizedNodeStreamWriter writer, final SchemaContext schemaContext) {
isEmpty = false;
CompositeNodeDataWithSchema compositeNodeDataWithSchema = new CompositeNodeDataWithSchema(schema);
read(reader, compositeNodeDataWithSchema);
- compositeNodeDataWithSchema.writeToStream(writer);
+ compositeNodeDataWithSchema.write(writer);
return this;
// return read(reader);
}
}
- public void read(final JsonReader in, final AbstractNodeDataWithSchema parent) throws IOException {
+ private final void setValue(final AbstractNodeDataWithSchema parent, final String value) {
+ Preconditions.checkArgument(parent instanceof SimpleNodeDataWithSchema, "Node %s is not a simple type", parent);
+
+ final Object translatedValue = translateValueByType(value, parent.getSchema());
+ ((SimpleNodeDataWithSchema) parent).setValue(translatedValue);
+ }
- final JsonToken peek = in.peek();
- Optional<String> value = Optional.absent();
- switch (peek) {
+ public void read(final JsonReader in, final AbstractNodeDataWithSchema parent) throws IOException {
+ switch (in.peek()) {
case STRING:
case NUMBER:
- value = Optional.of(in.nextString());
+ setValue(parent, in.nextString());
break;
case BOOLEAN:
- value = Optional.of(Boolean.toString(in.nextBoolean()));
+ setValue(parent, Boolean.toString(in.nextBoolean()));
break;
case NULL:
in.nextNull();
- value = Optional.of((String) null);
- break;
- default:
+ setValue(parent, null);
break;
- }
- if (value.isPresent()) {
- final Object translatedValue = translateValueByType(value.get(), parent.getSchema());
- ((SimpleNodeDataWithSchema) parent).setValue(translatedValue);
- }
-
- switch (peek) {
case BEGIN_ARRAY:
in.beginArray();
while (in.hasNext()) {
case NAME:
case END_OBJECT:
case END_ARRAY:
+ break;
}
}
return value;
}
- final Object inputValue;
- if (typeDefinition instanceof IdentityrefTypeDefinition) {
- inputValue = valueAsIdentityRef(value);
- } else if (typeDefinition instanceof InstanceIdentifierTypeDefinition) {
- inputValue = valueAsInstanceIdentifier(value);
- } else {
- inputValue = value;
- }
-
- // FIXME: extract this as a cacheable context?
- final Codec<Object, Object> codec = codecs.codecFor(typeDefinition);
- if (codec == null) {
- return null;
- }
- return codec.deserialize(inputValue);
+ return codecs.codecFor(typeDefinition).deserialize(value);
}
private static TypeDefinition<? extends Object> typeDefinition(final DataSchemaNode node) {
return baseType;
}
- private static Object valueAsInstanceIdentifier(final String value) {
- // it could be instance-identifier Built-In Type
- if (!value.isEmpty() && value.charAt(0) == '/') {
- IdentityValuesDTO resolvedValue = RestUtil.asInstanceIdentifier(value, new PrefixMapingFromJson());
- if (resolvedValue != null) {
- return resolvedValue;
- }
- }
- throw new InvalidParameterException("Value for instance-identifier doesn't have correct format");
- }
-
- private static IdentityValuesDTO valueAsIdentityRef(final String value) {
- // it could be identityref Built-In Type
- URI namespace = getNamespaceFor(value);
- if (namespace != null) {
- return new IdentityValuesDTO(namespace.toString(), getLocalNameFor(value), null, value);
- }
- throw new InvalidParameterException("Value for identityref has to be in format moduleName:localName.");
- }
-
- private static URI getNamespaceFor(final String jsonElementName) {
- final Iterator<String> it = COLON_SPLITTER.split(jsonElementName).iterator();
-
- // The string needs to me in form "moduleName:localName"
- if (it.hasNext()) {
- final String maybeURI = it.next();
- if (Iterators.size(it) == 1) {
- return URI.create(maybeURI);
- }
- }
-
- return null;
- }
-
- private static String getLocalNameFor(final String jsonElementName) {
- final Iterator<String> it = COLON_SPLITTER.split(jsonElementName).iterator();
-
- // The string needs to me in form "moduleName:localName"
- final String ret = Iterators.get(it, 1, null);
- return ret != null && !it.hasNext() ? ret : jsonElementName;
- }
-
private void removeNamespace() {
namespaces.pop();
}
}
private NamespaceAndName resolveNamespace(final String childName) {
- int lastIndexOfColon = childName.lastIndexOf(":");
+ int lastIndexOfColon = childName.lastIndexOf(':');
String moduleNamePart = null;
String nodeNamePart = null;
URI namespace = null;
if (lastIndexOfColon != -1) {
moduleNamePart = childName.substring(0, lastIndexOfColon);
nodeNamePart = childName.substring(lastIndexOfColon + 1);
- namespace = utils.findNamespaceByModuleName(moduleNamePart);
+
+ final Module m = schema.findModuleByName(moduleNamePart, null);
+ namespace = m == null ? null : m.getNamespace();
} else {
nodeNamePart = childName;
}
}
/**
- * Returns stack of schema nodes via which it was necessary to prass to get schema node with specified
+ * Returns stack of schema nodes via which it was necessary to pass to get schema node with specified
* {@code childName} and {@code namespace}
*
* @param dataSchemaNode
* @param childName
* @param namespace
- * @return stack of schema nodes via which it was passed through. If found schema node is dirrect child then stack
- * contains only one node. If it is found under choice and case then stack should conains 2*n+1 element
+ * @return stack of schema nodes via which it was passed through. If found schema node is direct child then stack
+ * contains only one node. If it is found under choice and case then stack should contains 2*n+1 element
* (where n is number of choices through it was passed)
*/
private Deque<DataSchemaNode> findSchemaNodeByNameAndNamespace(final DataSchemaNode dataSchemaNode,
}
@Override
- protected void writeToStream(final NormalizedNodeStreamWriter nnStreamWriter) throws IOException {
- nnStreamWriter.leafSetEntryNode(getValue());
+ public void write(final NormalizedNodeStreamWriter writer) throws IOException {
+ writer.leafSetEntryNode(getValue());
}
}
*/
package org.opendaylight.yangtools.yang.data.codec.gson;
-import static org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter.UNKNOWN_SIZE;
-
import java.io.IOException;
import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter;
}
@Override
- protected void writeToStream(final NormalizedNodeStreamWriter nnStreamWriter) throws IOException {
- nnStreamWriter.startLeafSet(provideNodeIdentifier(), UNKNOWN_SIZE);
- super.writeToStream(nnStreamWriter);
- nnStreamWriter.endNode();
+ public void write(final NormalizedNodeStreamWriter writer) throws IOException {
+ writer.startLeafSet(provideNodeIdentifier(), childSizeHint());
+ super.write(writer);
+ writer.endNode();
}
}
}
@Override
- protected void writeToStream(final NormalizedNodeStreamWriter nnStreamWriter) throws IOException {
- nnStreamWriter.leafNode(provideNodeIdentifier(), getValue());
+ public void write(final NormalizedNodeStreamWriter writer) throws IOException {
+ writer.leafNode(provideNodeIdentifier(), getValue());
}
}
*/
package org.opendaylight.yangtools.yang.data.codec.gson;
-import static org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter.UNKNOWN_SIZE;
+import com.google.common.base.Function;
+import com.google.common.base.Preconditions;
+import com.google.common.collect.Maps;
import java.io.IOException;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
+import javax.annotation.Nonnull;
+
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter;
import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
class ListEntryNodeDataWithSchema extends CompositeNodeDataWithSchema {
+ private static final Function<SimpleNodeDataWithSchema, Object> VALUE_FUNCTION = new Function<SimpleNodeDataWithSchema, Object>() {
+ @Override
+ public Object apply(@Nonnull final SimpleNodeDataWithSchema input) {
+ return input.getValue();
+ }
+ };
private final Map<QName, SimpleNodeDataWithSchema> qNameToKeys = new HashMap<>();
@Override
public void addChild(final AbstractNodeDataWithSchema newChild) {
- DataSchemaNode childSchema = newChild.getSchema();
+ final DataSchemaNode childSchema = newChild.getSchema();
if (childSchema instanceof LeafSchemaNode && isPartOfKey((LeafSchemaNode) childSchema)) {
qNameToKeys.put(childSchema.getQName(), (SimpleNodeDataWithSchema)newChild);
}
}
@Override
- protected void writeToStream(final NormalizedNodeStreamWriter nnStreamWriter) throws IOException {
- int keyCount = ((ListSchemaNode) getSchema()).getKeyDefinition().size();
+ public void write(final NormalizedNodeStreamWriter writer) throws IOException {
+ final int keyCount = ((ListSchemaNode) getSchema()).getKeyDefinition().size();
if (keyCount == 0) {
- nnStreamWriter.startUnkeyedListItem(provideNodeIdentifier(), UNKNOWN_SIZE);
- super.writeToStream(nnStreamWriter);
- nnStreamWriter.endNode();
- } else if (keyCount == qNameToKeys.size()) {
- nnStreamWriter.startMapEntryNode(provideNodeIdentifierWithPredicates(), UNKNOWN_SIZE);
- super.writeToStream(nnStreamWriter);
- nnStreamWriter.endNode();
- } else {
- throw new IllegalStateException("Some of keys of " + getSchema().getQName() + " are missing in input.");
+ writer.startUnkeyedListItem(provideNodeIdentifier(), childSizeHint());
+ super.write(writer);
+ writer.endNode();
+ return;
}
- }
-
- private NodeIdentifierWithPredicates provideNodeIdentifierWithPredicates() {
- Map<QName, Object> qNameToPredicateValues = new HashMap<>();
- for (SimpleNodeDataWithSchema simpleNodeDataWithSchema : qNameToKeys.values()) {
- qNameToPredicateValues.put(simpleNodeDataWithSchema.getSchema().getQName(), simpleNodeDataWithSchema.getValue());
- }
-
- return new NodeIdentifierWithPredicates(getSchema().getQName(), qNameToPredicateValues);
+ Preconditions.checkState(keyCount == qNameToKeys.size(), "Input is missing some of the keys of %s", getSchema().getQName());
+ writer.startMapEntryNode(
+ new NodeIdentifierWithPredicates(getSchema().getQName(), Maps.transformValues(qNameToKeys, VALUE_FUNCTION)),
+ childSizeHint());
+ super.write(writer);
+ writer.endNode();
}
-
}
*/
package org.opendaylight.yangtools.yang.data.codec.gson;
-import static org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter.UNKNOWN_SIZE;
-
import java.io.IOException;
import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter;
}
@Override
- protected void writeToStream(final NormalizedNodeStreamWriter nnStreamWriter) throws IOException {
- if (!((ListSchemaNode) getSchema()).getKeyDefinition().isEmpty()) {
- nnStreamWriter.startMapNode(provideNodeIdentifier(), UNKNOWN_SIZE);
+ public void write(final NormalizedNodeStreamWriter writer) throws IOException {
+ if (((ListSchemaNode) getSchema()).getKeyDefinition().isEmpty()) {
+ writer.startUnkeyedList(provideNodeIdentifier(), childSizeHint());
} else {
- nnStreamWriter.startUnkeyedList(provideNodeIdentifier(), UNKNOWN_SIZE);
+ writer.startMapNode(provideNodeIdentifier(), childSizeHint());
}
- super.writeToStream(nnStreamWriter);
- nnStreamWriter.endNode();
+ super.write(writer);
+ writer.endNode();
}
}
+++ /dev/null
-/*
- * Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.yangtools.yang.data.codec.gson.helpers;
-
-import com.google.common.base.Preconditions;
-
-import java.net.URI;
-
-import org.opendaylight.yangtools.yang.model.api.Module;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-abstract class AbstractCodecImpl {
- private static final Logger LOG = LoggerFactory.getLogger(AbstractCodecImpl.class);
- private final SchemaContextUtils schema;
-
- protected AbstractCodecImpl(final SchemaContextUtils schema) {
- this.schema = Preconditions.checkNotNull(schema);
- }
-
- protected final SchemaContextUtils getSchema() {
- return schema;
- }
-
- protected final Module getModuleByNamespace(final String namespace) {
- URI validNamespace = resolveValidNamespace(namespace);
-
- Module module = schema.findModuleByNamespace(validNamespace);
- if (module == null) {
- LOG.info("Module for namespace " + validNamespace + " wasn't found.");
- return null;
- }
- return module;
- }
-
- protected final URI resolveValidNamespace(final String namespace) {
- URI validNamespace = schema.findNamespaceByModuleName(namespace);
- if (validNamespace == null) {
- validNamespace = URI.create(namespace);
- }
-
- return validNamespace;
- }
-}
+++ /dev/null
-/*
- * Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.yangtools.yang.data.codec.gson.helpers;
-
-import com.google.common.annotations.Beta;
-
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
-
-/**
- * This class is implementation-internal and subject to change. Please do not use it.
- */
-@Beta
-public final class IdentityValuesDTO {
-
- private final List<IdentityValue> elementData = new ArrayList<>();
- private final String originValue;
-
- public IdentityValuesDTO(final String namespace, final String value, final String prefix, final String originValue) {
- elementData.add(new IdentityValue(namespace, value, prefix));
- this.originValue = originValue;
- }
-
- public IdentityValuesDTO(final String originValue) {
- this.originValue = originValue;
- }
-
- public IdentityValuesDTO() {
- originValue = null;
- }
-
- public void add(final String namespace, final String value, final String prefix) {
- elementData.add(new IdentityValue(namespace, value, prefix));
- }
-
- public void add(final IdentityValue identityValue) {
- elementData.add(identityValue);
- }
-
- public List<IdentityValue> getValuesWithNamespaces() {
- return Collections.unmodifiableList(elementData);
- }
-
- @Override
- public String toString() {
- return elementData.toString();
- }
-
- public String getOriginValue() {
- return originValue;
- }
-
- public static final class IdentityValue {
-
- private final String namespace;
- private final String value;
- private final String prefix;
- private List<Predicate> predicates;
-
- public IdentityValue(final String namespace, final String value, final String prefix) {
- this.namespace = namespace;
- this.value = value;
- this.prefix = prefix;
- }
-
- public String getNamespace() {
- return namespace;
- }
-
- public String getValue() {
- return value;
- }
-
- public String getPrefix() {
- return prefix;
- }
-
- public List<Predicate> getPredicates() {
- if (predicates == null) {
- return Collections.emptyList();
- }
- return Collections.unmodifiableList(predicates);
- }
-
- public void setPredicates(final List<Predicate> predicates) {
- this.predicates = predicates;
- }
-
- @Override
- public String toString() {
- StringBuilder sb = new StringBuilder();
- if (namespace != null) {
- sb.append(namespace);
- }
- if (prefix != null) {
- sb.append("(").append(prefix).append(")");
- }
- if (value != null) {
- sb.append(" - ").append(value);
- }
- if (predicates != null && !predicates.isEmpty()) {
- for (Predicate predicate : predicates) {
- sb.append("[");
- predicate.toString();
- sb.append("]");
- }
- }
- return sb.toString();
- }
-
- }
-
- public static final class Predicate {
-
- private final IdentityValue name;
- private final String value;
-
- public Predicate(final IdentityValue name, final String value) {
- super();
- this.name = name;
- this.value = value;
- }
-
- public IdentityValue getName() {
- return name;
- }
-
- public String getValue() {
- return value;
- }
-
- @Override
- public String toString() {
- StringBuilder sb = new StringBuilder();
- if (name != null) {
- sb.append(name.toString());
- }
- if (value != null) {
- sb.append("=").append(value);
- }
- return sb.toString();
- }
-
- public boolean isLeafList() {
- return name == null ? true : false;
- }
-
- }
-}
+++ /dev/null
-/*
- * Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.yangtools.yang.data.codec.gson.helpers;
-
-import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.data.api.codec.IdentityrefCodec;
-import org.opendaylight.yangtools.yang.data.codec.gson.helpers.IdentityValuesDTO.IdentityValue;
-import org.opendaylight.yangtools.yang.model.api.Module;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-class IdentityrefCodecImpl extends AbstractCodecImpl implements IdentityrefCodec<IdentityValuesDTO> {
- private static final Logger LOG = LoggerFactory.getLogger(IdentityrefCodecImpl.class);
-
- IdentityrefCodecImpl(final SchemaContextUtils schema) {
- super(schema);
- }
-
- @Override
- public IdentityValuesDTO serialize(final QName data) {
- return new IdentityValuesDTO(data.getNamespace().toString(), data.getLocalName(), data.getPrefix(), null);
- }
-
- @Override
- public QName deserialize(final IdentityValuesDTO data) {
- IdentityValue valueWithNamespace = data.getValuesWithNamespaces().get(0);
- Module module = getModuleByNamespace(valueWithNamespace.getNamespace());
- if (module == null) {
- LOG.info("Module was not found for namespace {}", valueWithNamespace.getNamespace());
- LOG.info("Idenetityref will be translated as NULL for data - {}", String.valueOf(valueWithNamespace));
- return null;
- }
-
- return QName.create(module.getNamespace(), module.getRevision(), valueWithNamespace.getValue());
- }
-
-}
\ No newline at end of file
+++ /dev/null
-/*
- * Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.yangtools.yang.data.codec.gson.helpers;
-
-import java.net.URI;
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-
-import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeWithValue;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
-import org.opendaylight.yangtools.yang.data.api.codec.InstanceIdentifierCodec;
-import org.opendaylight.yangtools.yang.data.codec.gson.helpers.IdentityValuesDTO.IdentityValue;
-import org.opendaylight.yangtools.yang.data.codec.gson.helpers.IdentityValuesDTO.Predicate;
-import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
-import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.Module;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-class InstanceIdentifierCodecImpl extends AbstractCodecImpl implements InstanceIdentifierCodec<IdentityValuesDTO> {
- private static final Logger LOG = LoggerFactory.getLogger(InstanceIdentifierCodecImpl.class);
-
- InstanceIdentifierCodecImpl(final SchemaContextUtils schema) {
- super(schema);
- }
-
- @Override
- public IdentityValuesDTO serialize(final YangInstanceIdentifier data) {
- IdentityValuesDTO identityValuesDTO = new IdentityValuesDTO();
- for (PathArgument pathArgument : data.getPathArguments()) {
- IdentityValue identityValue = qNameToIdentityValue(pathArgument.getNodeType());
- if (pathArgument instanceof NodeIdentifierWithPredicates && identityValue != null) {
- List<Predicate> predicates = keyValuesToPredicateList(((NodeIdentifierWithPredicates) pathArgument)
- .getKeyValues());
- identityValue.setPredicates(predicates);
- } else if (pathArgument instanceof NodeWithValue && identityValue != null) {
- List<Predicate> predicates = new ArrayList<>();
- String value = String.valueOf(((NodeWithValue) pathArgument).getValue());
- predicates.add(new Predicate(null, value));
- identityValue.setPredicates(predicates);
- }
- identityValuesDTO.add(identityValue);
- }
- return identityValuesDTO;
- }
-
- @Override
- public YangInstanceIdentifier deserialize(final IdentityValuesDTO data) {
- List<PathArgument> result = new ArrayList<PathArgument>();
- IdentityValue valueWithNamespace = data.getValuesWithNamespaces().get(0);
- Module module = getModuleByNamespace(valueWithNamespace.getNamespace());
- if (module == null) {
- LOG.info("Module by namespace '{}' of first node in instance-identiefier was not found.",
- valueWithNamespace.getNamespace());
- LOG.info("Instance-identifier will be translated as NULL for data - {}",
- String.valueOf(valueWithNamespace.getValue()));
- return null;
- }
-
- DataNodeContainer parentContainer = module;
- List<IdentityValue> identities = data.getValuesWithNamespaces();
- for (int i = 0; i < identities.size(); i++) {
- IdentityValue identityValue = identities.get(i);
- URI validNamespace = resolveValidNamespace(identityValue.getNamespace());
- DataSchemaNode node = getSchema().findInstanceDataChildByNameAndNamespace(
- parentContainer, identityValue.getValue(), validNamespace);
- if (node == null) {
- LOG.info("'{}' node was not found in {}", identityValue, parentContainer.getChildNodes());
- LOG.info("Instance-identifier will be translated as NULL for data - {}",
- String.valueOf(identityValue.getValue()));
- return null;
- }
- QName qName = node.getQName();
- PathArgument pathArgument = null;
- if (identityValue.getPredicates().isEmpty()) {
- pathArgument = new NodeIdentifier(qName);
- } else {
- if (node instanceof LeafListSchemaNode) { // predicate is value of leaf-list entry
- Predicate leafListPredicate = identityValue.getPredicates().get(0);
- if (!leafListPredicate.isLeafList()) {
- LOG.info("Predicate's data is not type of leaf-list. It should be in format \".='value'\"");
- LOG.info("Instance-identifier will be translated as NULL for data - {}",
- String.valueOf(identityValue.getValue()));
- return null;
- }
- pathArgument = new NodeWithValue(qName, leafListPredicate.getValue());
- } else if (node instanceof ListSchemaNode) { // predicates are keys of list
- DataNodeContainer listNode = (DataNodeContainer) node;
- Map<QName, Object> predicatesMap = new HashMap<>();
- for (Predicate predicate : identityValue.getPredicates()) {
- validNamespace = resolveValidNamespace(predicate.getName().getNamespace());
- DataSchemaNode listKey = getSchema()
- .findInstanceDataChildByNameAndNamespace(listNode, predicate.getName().getValue(),
- validNamespace);
- predicatesMap.put(listKey.getQName(), predicate.getValue());
- }
- pathArgument = new NodeIdentifierWithPredicates(qName, predicatesMap);
- } else {
- LOG.info("Node {} is not List or Leaf-list.", node);
- LOG.info("Instance-identifier will be translated as NULL for data - {}",
- String.valueOf(identityValue.getValue()));
- return null;
- }
- }
- result.add(pathArgument);
- if (i < identities.size() - 1) { // last element in instance-identifier can be other than
- // DataNodeContainer
- if (node instanceof DataNodeContainer) {
- parentContainer = (DataNodeContainer) node;
- } else {
- LOG.info("Node {} isn't instance of DataNodeContainer", node);
- LOG.info("Instance-identifier will be translated as NULL for data - {}",
- String.valueOf(identityValue.getValue()));
- return null;
- }
- }
- }
-
- return result.isEmpty() ? null : YangInstanceIdentifier.create(result);
- }
-
- private static List<Predicate> keyValuesToPredicateList(final Map<QName, Object> keyValues) {
- List<Predicate> result = new ArrayList<>(keyValues.size());
- for (Map.Entry<QName, Object> e : keyValues.entrySet()) {
- result.add(new Predicate(qNameToIdentityValue(e.getKey()), String.valueOf(e.getValue())));
- }
- return result;
- }
-
- private static IdentityValue qNameToIdentityValue(final QName qName) {
- if (qName != null) {
- // FIXME: the prefix here is completely arbitrary
- return new IdentityValue(qName.getNamespace().toString(), qName.getLocalName(), qName.getPrefix());
- }
- return null;
- }
-}
+++ /dev/null
-/*
- * Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.yangtools.yang.data.codec.gson.helpers;
-
-import org.opendaylight.yangtools.yang.data.api.codec.LeafrefCodec;
-
-class LeafrefCodecImpl implements LeafrefCodec<String> {
-
- @Override
- public String serialize(final Object data) {
- return String.valueOf(data);
- }
-
- @Override
- public Object deserialize(final String data) {
- return data;
- }
-
-}
\ No newline at end of file
+++ /dev/null
-/*
- * Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.yangtools.yang.data.codec.gson.helpers;
-
-import org.opendaylight.yangtools.concepts.Codec;
-import org.opendaylight.yangtools.yang.data.impl.codec.TypeDefinitionAwareCodec;
-import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
-import org.opendaylight.yangtools.yang.model.api.type.IdentityrefTypeDefinition;
-import org.opendaylight.yangtools.yang.model.api.type.InstanceIdentifierTypeDefinition;
-import org.opendaylight.yangtools.yang.model.api.type.LeafrefTypeDefinition;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-@SuppressWarnings("rawtypes")
-final class ObjectCodec extends AbstractCodecImpl implements Codec<Object, Object> {
- public static final Codec LEAFREF_DEFAULT_CODEC = new LeafrefCodecImpl();
- private static final Logger LOG = LoggerFactory.getLogger(RestCodecFactory.class);
- private final Codec instanceIdentifier;
- private final Codec identityrefCodec;
- private final TypeDefinition<?> type;
-
- ObjectCodec(final SchemaContextUtils schema, final TypeDefinition<?> typeDefinition) {
- super(schema);
- type = RestUtil.resolveBaseTypeFrom(typeDefinition);
- if (type instanceof IdentityrefTypeDefinition) {
- identityrefCodec = new IdentityrefCodecImpl(schema);
- } else {
- identityrefCodec = null;
- }
- if (type instanceof InstanceIdentifierTypeDefinition) {
- instanceIdentifier = new InstanceIdentifierCodecImpl(schema);
- } else {
- instanceIdentifier = null;
- }
- }
-
- @SuppressWarnings("unchecked")
- @Override
- public Object deserialize(final Object input) {
- try {
- if (type instanceof IdentityrefTypeDefinition) {
- if (input instanceof IdentityValuesDTO) {
- return identityrefCodec.deserialize(input);
- }
- LOG.debug("Value is not instance of IdentityrefTypeDefinition but is {}. Therefore NULL is used as translation of - {}",
- input == null ? "null" : input.getClass(), String.valueOf(input));
- return null;
- } else if (type instanceof LeafrefTypeDefinition) {
- if (input instanceof IdentityValuesDTO) {
- return LEAFREF_DEFAULT_CODEC.deserialize(((IdentityValuesDTO) input).getOriginValue());
- }
- return LEAFREF_DEFAULT_CODEC.deserialize(input);
- } else if (type instanceof InstanceIdentifierTypeDefinition) {
- if (input instanceof IdentityValuesDTO) {
- return instanceIdentifier.deserialize(input);
- }
- LOG.info(
- "Value is not instance of InstanceIdentifierTypeDefinition but is {}. Therefore NULL is used as translation of - {}",
- input == null ? "null" : input.getClass(), String.valueOf(input));
- return null;
- } else {
- TypeDefinitionAwareCodec<Object, ? extends TypeDefinition<?>> typeAwarecodec = TypeDefinitionAwareCodec
- .from(type);
- if (typeAwarecodec != null) {
- if (input instanceof IdentityValuesDTO) {
- return typeAwarecodec.deserialize(((IdentityValuesDTO) input).getOriginValue());
- }
- return typeAwarecodec.deserialize(String.valueOf(input));
- } else {
- LOG.debug("Codec for type \"" + type.getQName().getLocalName()
- + "\" is not implemented yet.");
- return null;
- }
- }
- } catch (ClassCastException e) {
- // TODO remove this catch when everyone use codecs
- LOG.error("ClassCastException was thrown when codec is invoked with parameter " + String.valueOf(input),
- e);
- return null;
- }
- }
-
- @SuppressWarnings("unchecked")
- @Override
- public Object serialize(final Object input) {
- try {
- if (type instanceof IdentityrefTypeDefinition) {
- return identityrefCodec.serialize(input);
- } else if (type instanceof LeafrefTypeDefinition) {
- return LEAFREF_DEFAULT_CODEC.serialize(input);
- } else if (type instanceof InstanceIdentifierTypeDefinition) {
- return instanceIdentifier.serialize(input);
- } else {
- TypeDefinitionAwareCodec<Object, ? extends TypeDefinition<?>> typeAwarecodec = TypeDefinitionAwareCodec
- .from(type);
- if (typeAwarecodec != null) {
- return typeAwarecodec.serialize(input);
- } else {
- LOG.debug("Codec for type \"" + type.getQName().getLocalName()
- + "\" is not implemented yet.");
- return null;
- }
- }
- } catch (ClassCastException e) { // TODO remove this catch when everyone use codecs
- LOG.error(
- "ClassCastException was thrown when codec is invoked with parameter " + String.valueOf(input),
- e);
- return input;
- }
- }
-
-}
\ No newline at end of file
+++ /dev/null
-/*
- * Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.yangtools.yang.data.codec.gson.helpers;
-
-import com.google.common.annotations.Beta;
-import com.google.common.base.Preconditions;
-
-import org.opendaylight.yangtools.concepts.Codec;
-import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
-
-/**
- * This class is implementation-internal and subject to change. Please do not use it.
- */
-@Beta
-public final class RestCodecFactory {
- private final SchemaContextUtils utils;
-
- private RestCodecFactory(final SchemaContextUtils utils) {
- this.utils = Preconditions.checkNotNull(utils);
- }
-
- public static RestCodecFactory create(final SchemaContextUtils utils) {
- return new RestCodecFactory(utils);
- }
-
- public final Codec<Object, Object> codecFor(final TypeDefinition<?> typeDefinition) {
- // FIXME: implement loadingcache
- return new ObjectCodec(utils, typeDefinition);
- }
-}
+++ /dev/null
-/*
- * Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.yangtools.yang.data.codec.gson.helpers;
-
-
-import com.google.common.annotations.Beta;
-
-import java.util.ArrayList;
-import java.util.List;
-import java.util.regex.Matcher;
-import java.util.regex.Pattern;
-
-import javax.xml.stream.events.StartElement;
-
-import org.opendaylight.yangtools.yang.data.codec.gson.helpers.IdentityValuesDTO.IdentityValue;
-import org.opendaylight.yangtools.yang.data.codec.gson.helpers.IdentityValuesDTO.Predicate;
-import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
-
-/**
- * This class is implementation-internal and subject to change. Please do not use it.
- */
-@Beta
-public final class RestUtil {
-
- // FIXME: BUG-1275: this is code duplicates data.impl.codec
-
- public static final String SQUOTE = "'";
- public static final String DQUOTE = "\"";
- private static final Pattern PREDICATE_PATTERN = Pattern.compile("\\[(.*?)\\]");
-
- public final static TypeDefinition<?> resolveBaseTypeFrom(final TypeDefinition<?> type) {
- TypeDefinition<?> superType = type;
- while (superType.getBaseType() != null) {
- superType = superType.getBaseType();
- }
- return superType;
- }
-
- public static IdentityValuesDTO asInstanceIdentifier(final String value, final PrefixesMaping prefixMap) {
- String valueTrimmed = value.trim();
- if (!valueTrimmed.startsWith("/")) {
- return null;
- }
- String[] xPathParts = valueTrimmed.split("/");
- if (xPathParts.length < 2) { // must be at least "/pr:node"
- return null;
- }
- IdentityValuesDTO identityValuesDTO = new IdentityValuesDTO(value);
- for (int i = 1; i < xPathParts.length; i++) {
- String xPathPartTrimmed = xPathParts[i].trim();
-
- String xPathPartStr = getIdAndPrefixAsStr(xPathPartTrimmed);
- IdentityValue identityValue = toIdentity(xPathPartStr, prefixMap);
- if (identityValue == null) {
- return null;
- }
-
- List<Predicate> predicates = toPredicates(xPathPartTrimmed, prefixMap);
- if (predicates == null) {
- return null;
- }
- identityValue.setPredicates(predicates);
-
- identityValuesDTO.add(identityValue);
- }
- return identityValuesDTO.getValuesWithNamespaces().isEmpty() ? null : identityValuesDTO;
- }
-
- private static String getIdAndPrefixAsStr(final String pathPart) {
- int predicateStartIndex = pathPart.indexOf("[");
- return predicateStartIndex == -1 ? pathPart : pathPart.substring(0, predicateStartIndex);
- }
-
- private static IdentityValue toIdentity(final String xPathPart, final PrefixesMaping prefixMap) {
- String xPathPartTrimmed = xPathPart.trim();
- if (xPathPartTrimmed.isEmpty()) {
- return null;
- }
- String[] prefixAndIdentifier = xPathPartTrimmed.split(":");
- // it is not "prefix:value"
- if (prefixAndIdentifier.length != 2) {
- return null;
- }
- String prefix = prefixAndIdentifier[0].trim();
- String identifier = prefixAndIdentifier[1].trim();
- if (prefix.isEmpty() || identifier.isEmpty()) {
- return null;
- }
- String namespace = prefixMap.getNamespace(prefix);
- return new IdentityValue(namespace, identifier, namespace.equals(prefix) ? null : prefix);
- }
-
- private static List<Predicate> toPredicates(final String predicatesStr, final PrefixesMaping prefixMap) {
- List<Predicate> result = new ArrayList<>();
- List<String> predicates = new ArrayList<>();
- Matcher matcher = PREDICATE_PATTERN.matcher(predicatesStr);
- while (matcher.find()) {
- predicates.add(matcher.group(1).trim());
- }
- for (String predicate : predicates) {
- int indexOfEqualityMark = predicate.indexOf("=");
- if (indexOfEqualityMark != -1) {
- String predicateValue = toPredicateValue(predicate.substring(indexOfEqualityMark + 1));
- if (predicate.startsWith(".")) { // it is leaf-list
- if (predicateValue == null) {
- return null;
- }
- result.add(new Predicate(null, predicateValue));
- } else {
- IdentityValue identityValue = toIdentity(predicate.substring(0, indexOfEqualityMark), prefixMap);
- if (identityValue == null || predicateValue == null) {
- return null;
- }
- result.add(new Predicate(identityValue, predicateValue));
- }
- }
- }
- return result;
- }
-
- private static String toPredicateValue(final String predicatedValue) {
- String predicatedValueTrimmed = predicatedValue.trim();
- if ((predicatedValueTrimmed.startsWith(DQUOTE) || predicatedValueTrimmed.startsWith(SQUOTE))
- && (predicatedValueTrimmed.endsWith(DQUOTE) || predicatedValueTrimmed.endsWith(SQUOTE))) {
- return predicatedValueTrimmed.substring(1, predicatedValueTrimmed.length() - 1);
- }
- return null;
- }
-
- public interface PrefixesMaping {
- public String getNamespace(String prefix);
- }
-
- public static class PrefixMapingFromXml implements PrefixesMaping {
- StartElement startElement = null;
-
- public PrefixMapingFromXml(final StartElement startElement) {
- this.startElement = startElement;
- }
-
- @Override
- public String getNamespace(final String prefix) {
- return startElement.getNamespaceContext().getNamespaceURI(prefix);
- }
- }
-
- public static class PrefixMapingFromJson implements PrefixesMaping {
-
- @Override
- public String getNamespace(final String prefix) {
- return prefix;
- }
- }
-
-}
+++ /dev/null
-/*
- * Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.yangtools.yang.data.codec.gson.helpers;
-
-import com.google.common.annotations.Beta;
-import com.google.common.base.Function;
-import com.google.common.base.Objects;
-import com.google.common.base.Preconditions;
-import com.google.common.base.Predicate;
-import com.google.common.collect.Iterables;
-
-import java.net.URI;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Set;
-
-import org.opendaylight.yangtools.yang.model.api.AnyXmlSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.ChoiceCaseNode;
-import org.opendaylight.yangtools.yang.model.api.ChoiceNode;
-import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
-import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.Module;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
-
-/**
- * This class is implementation-internal and subject to change. Please do not use it.
- */
-@Beta
-public final class SchemaContextUtils {
- private final SchemaContext schemaContext;
-
- private SchemaContextUtils(final SchemaContext schemaContext) {
- this.schemaContext = Preconditions.checkNotNull(schemaContext);
- }
-
- public static SchemaContextUtils create(final SchemaContext schemaContext) {
- return new SchemaContextUtils(schemaContext);
- }
-
- public URI findNamespaceByModuleName(final String moduleName) {
- final Module module = this.findModuleByName(moduleName);
- return module == null ? null : module.getNamespace();
- }
-
-
- public Module findModuleByName(final String moduleName) {
- checkPreconditions();
- Preconditions.checkArgument(moduleName != null && !moduleName.isEmpty());
- return schemaContext.findModuleByName(moduleName, null);
- }
-
- public Module findModuleByNamespace(final URI namespace) {
- this.checkPreconditions();
- Preconditions.checkArgument(namespace != null);
- return schemaContext.findModuleByNamespaceAndRevision(namespace, null);
- }
-
- private void checkPreconditions() {
- if (schemaContext == null) {
- throw new IllegalStateException("Schema context isn't set.");
- }
- }
-
- public DataSchemaNode findInstanceDataChildByNameAndNamespace(final DataNodeContainer container, final String name,
- final URI namespace) {
- Preconditions.<URI> checkNotNull(namespace);
-
- final List<DataSchemaNode> potentialSchemaNodes = findInstanceDataChildrenByName(container, name);
-
- Predicate<DataSchemaNode> filter = new Predicate<DataSchemaNode>() {
- @Override
- public boolean apply(final DataSchemaNode node) {
- return Objects.equal(node.getQName().getNamespace(), namespace);
- }
- };
-
- Iterable<DataSchemaNode> result = Iterables.filter(potentialSchemaNodes, filter);
- return Iterables.getFirst(result, null);
- }
-
- public List<DataSchemaNode> findInstanceDataChildrenByName(final DataNodeContainer container, final String name) {
- Preconditions.<DataNodeContainer> checkNotNull(container);
- Preconditions.<String> checkNotNull(name);
-
- List<DataSchemaNode> instantiatedDataNodeContainers = new ArrayList<DataSchemaNode>();
- collectInstanceDataNodeContainers(instantiatedDataNodeContainers, container, name);
- return instantiatedDataNodeContainers;
- }
-
- private void collectInstanceDataNodeContainers(final List<DataSchemaNode> potentialSchemaNodes,
- final DataNodeContainer container, final String name) {
-
- Predicate<DataSchemaNode> filter = new Predicate<DataSchemaNode>() {
- @Override
- public boolean apply(final DataSchemaNode node) {
- return Objects.equal(node.getQName().getLocalName(), name);
- }
- };
-
- Iterable<DataSchemaNode> nodes = Iterables.filter(container.getChildNodes(), filter);
-
- // Can't combine this loop with the filter above because the filter is
- // lazily-applied by Iterables.filter.
- for (final DataSchemaNode potentialNode : nodes) {
- if (isInstantiatedDataSchema(potentialNode)) {
- potentialSchemaNodes.add(potentialNode);
- }
- }
-
- Iterable<ChoiceNode> choiceNodes = Iterables.filter(container.getChildNodes(), ChoiceNode.class);
- Iterable<Set<ChoiceCaseNode>> map = Iterables.transform(choiceNodes, CHOICE_FUNCTION);
-
- final Iterable<ChoiceCaseNode> allCases = Iterables.<ChoiceCaseNode> concat(map);
- for (final ChoiceCaseNode caze : allCases) {
- collectInstanceDataNodeContainers(potentialSchemaNodes, caze, name);
- }
- }
-
- public boolean isInstantiatedDataSchema(final DataSchemaNode node) {
- return node instanceof LeafSchemaNode || node instanceof LeafListSchemaNode
- || node instanceof ContainerSchemaNode || node instanceof ListSchemaNode
- || node instanceof AnyXmlSchemaNode;
- }
-
- private final Function<ChoiceNode, Set<ChoiceCaseNode>> CHOICE_FUNCTION = new Function<ChoiceNode, Set<ChoiceCaseNode>>() {
- @Override
- public Set<ChoiceCaseNode> apply(final ChoiceNode node) {
- return node.getCases();
- }
- };
-
-}
import java.util.List;
import org.junit.BeforeClass;
+import org.junit.Ignore;
import org.junit.Test;
-import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild;
import org.opendaylight.yangtools.yang.data.api.schema.stream.LoggingNormalizedNodeStreamWriter;
import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter;
import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeWriter;
-import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNormalizedNodeStreamWriter;
import org.opendaylight.yangtools.yang.data.impl.schema.NormalizedNodeResult;
-import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.NormalizedNodeContainerBuilder;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.model.parser.api.YangContextParser;
import org.opendaylight.yangtools.yang.parser.impl.YangParserImpl;
*
* @throws IOException
*/
+ @Ignore
@Test
public void immutableNormalizedNodeStreamWriterDemonstration() throws IOException {
/*
"anyxml-in-data":"foo"
}
],
-
+
"lf13-any":{
"anyxml-in-data":"foo"
},
-
+
"lf14-any":"anyxml data",
-
+
"lflst11":["lflst11 value1","lflst11 value2"],
-
+
"lst11":[
- {
+ {
"key111":"key111 value",
"lf112":"/complexjson:cont1/complexjson:lflst11",
"lf113":"lf113 value",
"lf111":"lf111 value"
}
- ],
+ ],
"lf11" : "453",
"lf12_1" : "lf12 value",
- "lf13" : "lf13 value",
+ "lf13" : "lf13 value",
"complexjson-augmentation:lf15_11" : "lf15_11 value from augmentation",
"complexjson-augmentation:lf15_12" : "lf15_12 value from augmentation",
"lf15_11" : "one two",
"lf15_12" : "complexjson:lf11",
"lf15_21" : "lf15_21 value",
- "lf17" : "lf17 value",
-
+ "lf17" : "lf17 value",
+
"lst12":[
{
"lf121":"lf121 value"
}
]
}
-}
\ No newline at end of file
+}
namespace "ns:complex:json";
prefix cj;
- revision "2014-08-11" {
+ revision "2014-08-11" {
}
-
-
+
+
identity ident;
-
+
container cont1 {
-
+
anyxml lf12-any;
anyxml lf13-any;
anyxml lf14-any;
-
+
leaf lf11 {
type int32;
}
-
+
leaf-list lflst11 {
type string;
}
-
+
list lst11 {
key "key111 lf111";
leaf key111 {
type string;
}
}
-
+
list lst12 {
leaf lf121 {
type string;
type string;
}
}
-
-
+
+
choice choc11 {
case c11A {
leaf lf13 {
}
}
}
-
-
+
augment "/cont1/choc12" {
case c12B {
leaf lf17 {
type string;
}
}
- }
-
-
+ }
+
augment "/cont1" {
container cont11 {
leaf lf111 {
type string;
}
- }
+ }
}
-
+
augment "/cont1" {
leaf lf12_1 {
- type string;
- }
+ type string;
+ }
leaf lf12_2 {
type string;
}
}
-
+
augment "/cont1" {
leaf lf12_3 {
- type string;
- }
+ type string;
+ }
}
-
-
+
augment "/cont1/choc11" {
case c11B {
leaf lf14_1 {
- type string;
- }
+ type string;
+ }
}
}
-
+
augment "/cont1/choc11" {
case c11C {
leaf lf14_2 {
- type string;
- }
+ type string;
+ }
}
}
-
+
augment "/cont1/choc11/c11A" {
leaf lf15_11 {
- type bits {
- bit one;
- bit two;
- bit three;
- }
- }
+ type bits {
+ bit one;
+ bit two;
+ bit three;
+ }
+ }
leaf lf15_12 {
- type identityref {
- base ident;
- }
- }
-
+ type identityref {
+ base ident;
+ }
+ }
+
}
-
+
augment "/cont1/choc11/c11A" {
leaf lf15_21 {
- type string;
- }
+ type string;
+ }
}
}
import org.opendaylight.yangtools.yang.binding.BindingCodec;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
-public interface InstanceIdentifierCodec extends BindingCodec<org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier,InstanceIdentifier<?>> {
-
+public interface InstanceIdentifierCodec extends BindingCodec<YangInstanceIdentifier, InstanceIdentifier<?>> {
@Override
- org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier serialize(InstanceIdentifier<?> input);
+ YangInstanceIdentifier serialize(InstanceIdentifier<?> input);
@Override
- InstanceIdentifier<?> deserialize(org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier input);
+ InstanceIdentifier<?> deserialize(YangInstanceIdentifier input);
}
--- /dev/null
+/*
+ * Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.data.impl.codec;
+
+import com.google.common.annotations.Beta;
+import com.google.common.base.Preconditions;
+import java.io.IOException;
+import java.util.ArrayDeque;
+import java.util.Deque;
+import java.util.HashSet;
+import javax.xml.stream.XMLStreamWriter;
+import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
+import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter;
+import org.opendaylight.yangtools.yang.data.impl.schema.SchemaUtils;
+import org.opendaylight.yangtools.yang.data.impl.schema.transform.base.AugmentationSchemaProxy;
+import org.opendaylight.yangtools.yang.model.api.AnyXmlSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.AugmentationSchema;
+import org.opendaylight.yangtools.yang.model.api.AugmentationTarget;
+import org.opendaylight.yangtools.yang.model.api.ChoiceNode;
+import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
+import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+import org.opendaylight.yangtools.yang.model.api.SchemaNode;
+import org.opendaylight.yangtools.yang.model.api.SchemaPath;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * Utility class for tracking the underlying state of the underlying
+ * schema node.
+ */
+@Beta
+public final class SchemaTracker {
+ private static final Logger LOG = LoggerFactory.getLogger(SchemaTracker.class);
+ private final Deque<Object> schemaStack = new ArrayDeque<>();
+ private final DataNodeContainer root;
+
+ private SchemaTracker(final SchemaContext context, final SchemaPath path) {
+ DataNodeContainer current = Preconditions.checkNotNull(context);
+ for (QName qname : path.getPathFromRoot()) {
+ final DataSchemaNode child = current.getDataChildByName(qname);
+ Preconditions.checkArgument(child instanceof DataNodeContainer);
+ current = (DataNodeContainer) child;
+ }
+
+ this.root = current;
+ }
+
+ /**
+ * Create a new writer with the specified context as its root.
+ *
+ * @param writer Output {@link XMLStreamWriter}
+ * @param context Associated {@link SchemaContext}.
+ * @return A new {@link NormalizedNodeStreamWriter}
+ */
+ public static SchemaTracker create(final SchemaContext context) {
+ return create(context, SchemaPath.ROOT);
+ }
+
+ /**
+ * Create a new writer with the specified context and rooted in the specified schema path
+ *
+ * @param writer Output {@link XMLStreamWriter}
+ * @param context Associated {@link SchemaContext}.
+ *
+ * @return A new {@link NormalizedNodeStreamWriter}
+ */
+ public static SchemaTracker create(final SchemaContext context, final SchemaPath path) {
+ return new SchemaTracker(context, path);
+ }
+
+ public Object getParent() {
+ if (schemaStack.isEmpty()) {
+ return root;
+ }
+ return schemaStack.peek();
+ }
+
+ private SchemaNode getSchema(final PathArgument name) {
+ final Object parent = getParent();
+ Preconditions.checkState(parent instanceof DataNodeContainer);
+
+ final QName qname = name.getNodeType();
+ final SchemaNode schema = ((DataNodeContainer)parent).getDataChildByName(qname);
+ Preconditions.checkArgument(schema != null, "Could not find schema for node %s in %s", qname, parent);
+ return schema;
+ }
+
+ public void startList(final NodeIdentifier name) {
+ final SchemaNode schema = getSchema(name);
+ Preconditions.checkArgument(schema instanceof ListSchemaNode, "Node %s is not a list", schema.getPath());
+ schemaStack.push(schema);
+ }
+
+ public void startListItem(final PathArgument name) throws IOException {
+ final Object schema = getParent();
+ Preconditions.checkArgument(schema instanceof ListSchemaNode, "List item is not appropriate");
+ schemaStack.push(schema);
+ }
+
+ public LeafSchemaNode leafNode(final NodeIdentifier name) throws IOException {
+ final SchemaNode schema = getSchema(name);
+
+ Preconditions.checkArgument(schema instanceof LeafSchemaNode, "Node %s is not a leaf", schema.getPath());
+ return (LeafSchemaNode) schema;
+ }
+
+ public SchemaNode startLeafSet(final NodeIdentifier name) {
+ final SchemaNode schema = getSchema(name);
+
+ Preconditions.checkArgument(schema instanceof LeafListSchemaNode, "Node %s is not a leaf-list", schema.getPath());
+ schemaStack.push(schema);
+ return schema;
+ }
+
+ public LeafListSchemaNode leafSetEntryNode() {
+ final Object parent = getParent();
+
+ Preconditions.checkArgument(parent instanceof LeafListSchemaNode, "Not currently in a leaf-list");
+ return (LeafListSchemaNode) parent;
+ }
+
+ public SchemaNode startChoiceNode(final NodeIdentifier name) {
+ LOG.debug("Enter choice {}", name);
+ final SchemaNode schema = getSchema(name);
+
+ Preconditions.checkArgument(schema instanceof ChoiceNode, "Node %s is not a choice", schema.getPath());
+ schemaStack.push(schema);
+ return schema;
+ }
+
+ public SchemaNode startContainerNode(final NodeIdentifier name) {
+ LOG.debug("Enter container {}", name);
+ final SchemaNode schema = getSchema(name);
+
+ Preconditions.checkArgument(schema instanceof ContainerSchemaNode, "Node %s is not a container", schema.getPath());
+ schemaStack.push(schema);
+ return schema;
+ }
+
+ public AugmentationSchema startAugmentationNode(final AugmentationIdentifier identifier) {
+ LOG.debug("Enter augmentation {}", identifier);
+ final Object parent = getParent();
+
+ Preconditions.checkArgument(parent instanceof AugmentationTarget, "Augmentation not allowed under %s", parent);
+ Preconditions.checkArgument(parent instanceof DataNodeContainer, "Augmentation allowed only in DataNodeContainer",parent);
+ final AugmentationSchema schema = SchemaUtils.findSchemaForAugment((AugmentationTarget) parent, identifier.getPossibleChildNames());
+ HashSet<DataSchemaNode> realChildSchemas = new HashSet<>();
+ for(DataSchemaNode child : schema.getChildNodes()) {
+ realChildSchemas.add(((DataNodeContainer) parent).getDataChildByName(child.getQName()));
+ }
+ AugmentationSchema resolvedSchema = new AugmentationSchemaProxy(schema, realChildSchemas);
+ schemaStack.push(resolvedSchema);
+ return resolvedSchema;
+ }
+
+ public AnyXmlSchemaNode anyxmlNode(final NodeIdentifier name) {
+ final SchemaNode schema = getSchema(name);
+
+ Preconditions.checkArgument(schema instanceof AnyXmlSchemaNode, "Node %s is not anyxml", schema.getPath());
+ return (AnyXmlSchemaNode)schema;
+ }
+
+ public Object endNode() {
+ return schemaStack.pop();
+ }
+}
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.Sets;
import com.google.common.io.BaseEncoding;
-
import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.Set;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
-
import javax.xml.bind.DatatypeConverter;
-
import org.opendaylight.yangtools.yang.data.api.codec.BinaryCodec;
import org.opendaylight.yangtools.yang.data.api.codec.BitsCodec;
import org.opendaylight.yangtools.yang.data.api.codec.BooleanCodec;
return 8;
} else {
String formatedMessage = String.format("Incorrect lexical representation of integer value: %s."
- + "\nAn integer value can be defined as: "
- + "\n - a decimal number,"
- + "\n - a hexadecimal number (prefix 0x),"
- + "\n - an octal number (prefix 0)."
- + "\nSigned values are allowed. Spaces between digits are NOT allowed.", integer);
+ + "%nAn integer value can be defined as: "
+ + "%n - a decimal number,"
+ + "%n - a hexadecimal number (prefix 0x),"
+ + "%n - an octal number (prefix 0)."
+ + "%nSigned values are allowed. Spaces between digits are NOT allowed.", integer);
throw new NumberFormatException(formatedMessage);
}
}
@Override
public String deserialize(final String stringRepresentation) {
- return stringRepresentation == null ? "" :stringRepresentation;
+ return stringRepresentation == null ? "" : stringRepresentation;
}
@Override
public String serialize(final String data) {
- return data == null ? "" : data.toString();
+ return data == null ? "" : data;
}
};
--- /dev/null
+/*
+ * Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.data.impl.codec.xml;
+
+import com.google.common.base.Preconditions;
+
+import java.io.IOException;
+
+import javax.xml.stream.XMLOutputFactory;
+import javax.xml.stream.XMLStreamException;
+import javax.xml.stream.XMLStreamWriter;
+
+import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.data.api.Node;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
+import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter;
+import org.opendaylight.yangtools.yang.data.impl.codec.SchemaTracker;
+import org.opendaylight.yangtools.yang.model.api.AnyXmlSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+import org.opendaylight.yangtools.yang.model.api.SchemaNode;
+import org.opendaylight.yangtools.yang.model.api.SchemaPath;
+import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
+
+/**
+ * A {@link NormalizedNodeStreamWriter} which translates the events into an
+ * {@link XMLStreamWriter}, resulting in a RFC 6020 XML encoding.
+ */
+public final class XMLStreamNormalizedNodeStreamWriter implements NormalizedNodeStreamWriter {
+ private static final XmlStreamUtils UTILS = XmlStreamUtils.create(XmlUtils.DEFAULT_XML_CODEC_PROVIDER);
+
+ private final XMLStreamWriter writer;
+ private final SchemaTracker tracker;
+
+ private XMLStreamNormalizedNodeStreamWriter(final XMLStreamWriter writer, final SchemaContext context, final SchemaPath path) {
+ this.writer = Preconditions.checkNotNull(writer);
+ this.tracker = SchemaTracker.create(context, path);
+ }
+
+ /**
+ * Create a new writer with the specified context as its root.
+ *
+ * @param writer Output {@link XMLStreamWriter}
+ * @param context Associated {@link SchemaContext}.
+ * @return A new {@link NormalizedNodeStreamWriter}
+ */
+ public static NormalizedNodeStreamWriter create(final XMLStreamWriter writer, final SchemaContext context) {
+ return create( writer, context, SchemaPath.ROOT);
+ }
+
+ /**
+ * Create a new writer with the specified context and rooted in the specified schema path
+ *
+ * @param writer Output {@link XMLStreamWriter}
+ * @param context Associated {@link SchemaContext}.
+ *
+ * @return A new {@link NormalizedNodeStreamWriter}
+ */
+ public static NormalizedNodeStreamWriter create(final XMLStreamWriter writer, final SchemaContext context, final SchemaPath path) {
+ final Boolean repairing = (Boolean) writer.getProperty(XMLOutputFactory.IS_REPAIRING_NAMESPACES);
+ Preconditions.checkArgument(repairing == true, "XML Stream Writer has to be repairing namespaces");
+ return new XMLStreamNormalizedNodeStreamWriter(writer, context, path);
+ }
+
+ private void writeElement(final QName qname, final TypeDefinition<?> type, final Object value) throws IOException {
+ final String ns = qname.getNamespace().toString();
+
+ try {
+ if (value != null) {
+ writer.writeStartElement(ns, qname.getLocalName());
+ UTILS.writeValue(writer, type, value);
+ writer.writeEndElement();
+ } else {
+ writer.writeEmptyElement(ns, qname.getLocalName());
+ }
+ } catch (XMLStreamException e) {
+ throw new IOException("Failed to emit element", e);
+ }
+ }
+
+ private void startElement(final QName qname) throws IOException {
+ try {
+ writer.writeStartElement(qname.getNamespace().toString(), qname.getLocalName());
+ } catch (XMLStreamException e) {
+ throw new IOException("Failed to start element", e);
+ }
+ }
+
+ private void startList(final NodeIdentifier name) {
+ tracker.startList(name);
+ }
+
+ private void startListItem(final PathArgument name) throws IOException {
+ tracker.startListItem(name);
+ startElement(name.getNodeType());
+ }
+
+ @Override
+ public void leafNode(final NodeIdentifier name, final Object value) throws IOException {
+ final LeafSchemaNode schema = tracker.leafNode(name);
+
+ writeElement(schema.getQName(), schema.getType(), value);
+ }
+
+ @Override
+ public void startLeafSet(final NodeIdentifier name, final int childSizeHint) {
+ tracker.startLeafSet(name);
+ }
+
+ @Override
+ public void leafSetEntryNode(final Object value) throws IOException {
+ final LeafListSchemaNode schema = tracker.leafSetEntryNode();
+ writeElement(schema.getQName(), schema.getType(), value);
+ }
+
+ @Override
+ public void startContainerNode(final NodeIdentifier name, final int childSizeHint) throws IOException {
+ final SchemaNode schema = tracker.startContainerNode(name);
+ startElement(schema.getQName());
+ }
+
+ @Override
+ public void startUnkeyedList(final NodeIdentifier name, final int childSizeHint) {
+ startList(name);
+ }
+
+ @Override
+ public void startUnkeyedListItem(final NodeIdentifier name, final int childSizeHint) throws IOException {
+ startListItem(name);
+ }
+
+ @Override
+ public void startMapNode(final NodeIdentifier name, final int childSizeHint) {
+ startList(name);
+ }
+
+ @Override
+ public void startMapEntryNode(final NodeIdentifierWithPredicates identifier, final int childSizeHint) throws IOException {
+ startListItem(identifier);
+ }
+
+ @Override
+ public void startOrderedMapNode(final NodeIdentifier name, final int childSizeHint) {
+ startList(name);
+ }
+
+ @Override
+ public void startChoiceNode(final NodeIdentifier name, final int childSizeHint) {
+ tracker.startChoiceNode(name);
+ }
+
+ @Override
+ public void startAugmentationNode(final AugmentationIdentifier identifier) {
+ tracker.startAugmentationNode(identifier);
+ }
+
+ @Override
+ public void anyxmlNode(final NodeIdentifier name, final Object value) throws IOException {
+ final AnyXmlSchemaNode schema = tracker.anyxmlNode(name);
+ final QName qname = schema.getQName();
+ final String ns = qname.getNamespace().toString();
+
+ try {
+ if (value != null) {
+ writer.writeStartElement(ns, qname.getLocalName());
+ UTILS.writeValue(writer, (Node<?>)value, schema);
+ writer.writeEndElement();
+ } else {
+ writer.writeEmptyElement(ns, qname.getLocalName());
+ }
+ } catch (XMLStreamException e) {
+ throw new IOException("Failed to emit element", e);
+ }
+ }
+
+ @Override
+ public void endNode() throws IOException {
+ final Object schema = tracker.endNode();
+
+ try {
+ if (schema instanceof ListSchemaNode) {
+ // For lists, we only emit end element on the inner frame
+ final Object parent = tracker.getParent();
+ if (parent == schema) {
+ writer.writeEndElement();
+ }
+ } else if (schema instanceof ContainerSchemaNode) {
+ // Emit container end element
+ writer.writeEndElement();
+ }
+ } catch (XMLStreamException e) {
+ throw new IOException("Failed to end element", e);
+ }
+ }
+
+ @Override
+ public void close() throws IOException {
+ try {
+ writer.close();
+ } catch (XMLStreamException e) {
+ throw new IOException("Failed to close writer", e);
+ }
+ }
+
+ @Override
+ public void flush() throws IOException {
+ try {
+ writer.flush();
+ } catch (XMLStreamException e) {
+ throw new IOException("Failed to flush writer", e);
+ }
+ }
+}
throw new UnsupportedOperationException("Utilities class should not be instantiated");
}
- public static final CollectionNodeBuilder<MapEntryNode, MapNode> mapNodeBuilder() {
+ public static CollectionNodeBuilder<MapEntryNode, MapNode> mapNodeBuilder() {
return ImmutableMapNodeBuilder.create();
}
- public static final CollectionNodeBuilder<MapEntryNode, MapNode> mapNodeBuilder(final QName name) {
+ public static CollectionNodeBuilder<MapEntryNode, MapNode> mapNodeBuilder(final QName name) {
return ImmutableMapNodeBuilder.create().withNodeIdentifier(new NodeIdentifier(name));
}
* @param value Value of leaf node
* @return Leaf node with supplied identifier and value
*/
- public static final <T> LeafNode<T> leafNode(final NodeIdentifier name,final T value) {
+ public static <T> LeafNode<T> leafNode(final NodeIdentifier name,final T value) {
return ImmutableLeafNodeBuilder.<T>create()
.withNodeIdentifier(name)
.withValue(value)
}
/**
- *
* Construct immutable leaf node
*
* @param name QName which will be used as node identifier
* @param value Value of leaf node.
* @return Leaf node with supplied identifier and value
*/
- public static final <T> LeafNode<T> leafNode(final QName name,final T value) {
+ public static <T> LeafNode<T> leafNode(final QName name,final T value) {
return leafNode(new NodeIdentifier(name), value);
}
--- /dev/null
+/*
+ * Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.data.util;
+
+import com.google.common.annotations.Beta;
+import com.google.common.base.Preconditions;
+
+import javax.annotation.Nonnull;
+
+import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.model.api.Module;
+
+@Beta
+public abstract class AbstractModuleStringIdentityrefCodec extends AbstractStringIdentityrefCodec {
+ /**
+ * Resolve a string prefix into the corresponding module.
+ *
+ * @param prefix
+ * @return module mapped to prefix, or null if the module cannot be resolved
+ */
+ protected abstract Module moduleForPrefix(@Nonnull String prefix);
+
+ @Override
+ protected final QName createQName(final String prefix, final String localName) {
+ final Module module = moduleForPrefix(prefix);
+ Preconditions.checkArgument(module != null, "Failed to lookup prefix %s", prefix);
+ return QName.create(module.getQNameModule(), localName);
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.data.util;
+
+import com.google.common.annotations.Beta;
+import com.google.common.base.Preconditions;
+
+import javax.annotation.Nonnull;
+
+import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.model.api.Module;
+
+/**
+ * Extension of {@link AbstractStringInstanceIdentifierCodec}, which instantiates
+ * QNames by first resolving the namespace and then looking the target namespace
+ * in the list of currently-subscribed modules.
+ */
+@Beta
+public abstract class AbstractModuleStringInstanceIdentifierCodec extends AbstractStringInstanceIdentifierCodec {
+ /**
+ * Resolve a string prefix into the corresponding module.
+ *
+ * @param prefix
+ * @return module mapped to prefix, or null if the module cannot be resolved
+ */
+ protected abstract Module moduleForPrefix(@Nonnull String prefix);
+
+ @Override
+ protected final QName createQName(final String prefix, final String localName) {
+ final Module module = moduleForPrefix(prefix);
+ Preconditions.checkArgument(module != null, "Failed to lookup prefix %s", prefix);
+ return QName.create(module.getQNameModule(), localName);
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.data.util;
+
+import com.google.common.base.Preconditions;
+import com.google.common.base.Splitter;
+
+import java.net.URI;
+import java.util.Iterator;
+
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+
+import org.opendaylight.yangtools.yang.common.QName;
+
+abstract class AbstractNamespaceCodec {
+ private static final Splitter COLON_SPLITTER = Splitter.on(':');
+
+ /**
+ * Return string prefix for a particular namespace, allocating a new one if necessary.
+ *
+ * @param namespace Namespace to map
+ * @return Allocated unique prefix, or null if the prefix cannot be mapped.
+ */
+ protected abstract @Nullable String prefixForNamespace(final @Nonnull URI namespace);
+
+ /**
+ * Create a QName for a prefix and local name.
+ *
+ * @param prefix Prefix for namespace
+ * @param localName local name
+ * @return QName
+ * @throws IllegalArgumentException if the prefix cannot be resolved
+ */
+ protected abstract @Nullable QName createQName(final @Nonnull String prefix, final @Nonnull String localName);
+
+ private static String getIdAndPrefixAsStr(final String pathPart) {
+ int predicateStartIndex = pathPart.indexOf('[');
+ return predicateStartIndex == -1 ? pathPart : pathPart.substring(0, predicateStartIndex);
+ }
+
+ protected final StringBuilder appendQName(final StringBuilder sb, final QName qname) {
+ final String prefix = prefixForNamespace(qname.getNamespace());
+ Preconditions.checkArgument(prefix != null, "Failed to map QName {}", qname);
+ sb.append(prefix);
+ sb.append(':');
+ sb.append(qname.getLocalName());
+ return sb;
+ }
+
+ protected final QName parseQName(final String str) {
+ final String xPathPartTrimmed = getIdAndPrefixAsStr(str).trim();
+ final Iterator<String> it = COLON_SPLITTER.split(xPathPartTrimmed).iterator();
+
+ // Empty string
+ if (!it.hasNext()) {
+ return null;
+ }
+
+ final String prefix = it.next().trim();
+ if (prefix.isEmpty()) {
+ return null;
+ }
+
+ // it is not "prefix:value"
+ if (!it.hasNext()) {
+ return null;
+ }
+
+ final String identifier = it.next().trim();
+ if (identifier.isEmpty()) {
+ return null;
+ }
+
+ return createQName(prefix, identifier);
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.data.util;
+
+import com.google.common.annotations.Beta;
+
+import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.data.api.codec.IdentityrefCodec;
+
+/**
+ * Abstract utility class for representations which encode Identityref as a
+ * prefix:name tuple. Typical uses are RESTCONF/JSON (module:name) and XML (prefix:name).
+ */
+@Beta
+public abstract class AbstractStringIdentityrefCodec extends AbstractNamespaceCodec implements IdentityrefCodec<String> {
+ @Override
+ public String serialize(final QName data) {
+ return appendQName(new StringBuilder(), data).toString();
+ }
+
+ @Override
+ public QName deserialize(final String data) {
+ return parseQName(data);
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.data.util;
+
+import com.google.common.annotations.Beta;
+import com.google.common.base.Preconditions;
+import com.google.common.base.Splitter;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeWithValue;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
+import org.opendaylight.yangtools.yang.data.api.codec.InstanceIdentifierCodec;
+
+/**
+ * Abstract utility class for representations which encode {@link YangInstanceIdentifier} as a
+ * prefix:name tuple. Typical uses are RESTCONF/JSON (module:name) and XML (prefix:name).
+ */
+@Beta
+public abstract class AbstractStringInstanceIdentifierCodec extends AbstractNamespaceCodec implements InstanceIdentifierCodec<String> {
+ private static final Pattern PREDICATE_PATTERN = Pattern.compile("\\[(.*?)\\]");
+ private static final Splitter SLASH_SPLITTER = Splitter.on('/');
+
+ @Override
+ public final String serialize(final YangInstanceIdentifier data) {
+ StringBuilder sb = new StringBuilder();
+ for (PathArgument arg : data.getPathArguments()) {
+ sb.append('/');
+ appendQName(sb, arg.getNodeType());
+
+ if (arg instanceof NodeIdentifierWithPredicates) {
+ for (Map.Entry<QName, Object> entry : ((NodeIdentifierWithPredicates) arg).getKeyValues().entrySet()) {
+ sb.append('[');
+ appendQName(sb, entry.getKey());
+ sb.append("='");
+ sb.append(String.valueOf(entry.getValue()));
+ sb.append("']");
+ }
+ } else if (arg instanceof NodeWithValue) {
+ sb.append("[.='");
+ sb.append(((NodeWithValue) arg).getValue());
+ sb.append("']");
+ }
+ }
+
+ return sb.toString();
+ }
+
+ @Override
+ public final YangInstanceIdentifier deserialize(final String data) {
+ Preconditions.checkNotNull(data, "Data may not be null");
+
+ final Iterator<String> xPathParts = SLASH_SPLITTER.split(data).iterator();
+
+ // must be at least "/pr:node"
+ if (!xPathParts.hasNext() || !xPathParts.next().isEmpty() || !xPathParts.hasNext()) {
+ return null;
+ }
+
+ List<PathArgument> result = new ArrayList<>();
+ while (xPathParts.hasNext()) {
+ String xPathPartTrimmed = xPathParts.next().trim();
+
+ PathArgument pathArgument = toPathArgument(xPathPartTrimmed);
+ if (pathArgument != null) {
+ result.add(pathArgument);
+ }
+ }
+ return YangInstanceIdentifier.create(result);
+ }
+
+ private PathArgument toPathArgument(final String xPathArgument) {
+ final QName mainQName = parseQName(xPathArgument);
+
+ // predicates
+ final Matcher matcher = PREDICATE_PATTERN.matcher(xPathArgument);
+ final Map<QName, Object> predicates = new HashMap<>();
+ QName currentQName = mainQName;
+
+ while (matcher.find()) {
+ final String predicateStr = matcher.group(1).trim();
+ final int indexOfEqualityMark = predicateStr.indexOf('=');
+ if (indexOfEqualityMark != -1) {
+ final String predicateValue = toPredicateValue(predicateStr.substring(indexOfEqualityMark + 1));
+ if (predicateValue == null) {
+ return null;
+ }
+
+ if (predicateStr.charAt(0) != '.') {
+ // target is not a leaf-list
+ currentQName = parseQName(predicateStr.substring(0, indexOfEqualityMark));
+ if (currentQName == null) {
+ return null;
+ }
+ }
+ predicates.put(currentQName, predicateValue);
+ }
+ }
+
+ if (predicates.isEmpty()) {
+ return new YangInstanceIdentifier.NodeIdentifier(mainQName);
+ } else {
+ return new YangInstanceIdentifier.NodeIdentifierWithPredicates(mainQName, predicates);
+ }
+ }
+
+ private static String toPredicateValue(final String predicatedValue) {
+ final String predicatedValueTrimmed = predicatedValue.trim();
+ if (predicatedValue.isEmpty()) {
+ return null;
+ }
+
+ switch (predicatedValueTrimmed.charAt(0)) {
+ case '"':
+ return trimIfEndIs(predicatedValueTrimmed, '"');
+ case '\'':
+ return trimIfEndIs(predicatedValueTrimmed, '\'');
+ default:
+ return null;
+ }
+ }
+
+ private static String trimIfEndIs(final String str, final char end) {
+ final int l = str.length() - 1;
+ if (str.charAt(l) != end) {
+ return null;
+ }
+
+ return str.substring(1, l);
+ }
+}
private final MavenProject project;
private final boolean inspectDependencies;
private final BuildContext buildContext;
- private YangProvider yangProvider;
+ private final YangProvider yangProvider;
@VisibleForTesting
YangToSourcesProcessor(Log log, File yangFilesRootDir, File[] excludedFiles, List<CodeGeneratorArg> codeGenerators,
static class YangProvider {
-
-
void addYangsToMetaInf(Log log, MavenProject project, File yangFilesRootDir, File[] excludedFiles)
throws MojoFailureException {
// copy project's src/main/yang/*.yang to target/generated-sources/yang/META-INF/yang/*.yang
+
File generatedYangDir = new File(project.getBasedir(), CodeGeneratorArg.YANG_GENERATED_DIR);
+ addYangsToMetaInf(log, project, yangFilesRootDir, excludedFiles, generatedYangDir);
+
+ // Also copy to the actual build output dir if different than "target". When running in
+ // Eclipse this can differ (eg "target-ide").
+
+ File actualGeneratedYangDir = new File(project.getBuild().getDirectory(),
+ CodeGeneratorArg.YANG_GENERATED_DIR.replace("target" + File.separator, ""));
+ if(!actualGeneratedYangDir.equals(generatedYangDir)) {
+ addYangsToMetaInf(log, project, yangFilesRootDir, excludedFiles, actualGeneratedYangDir);
+ }
+ }
+
+ private void addYangsToMetaInf(Log log, MavenProject project, File yangFilesRootDir,
+ File[] excludedFiles, File generatedYangDir)
+ throws MojoFailureException {
File withMetaInf = new File(generatedYangDir, META_INF_YANG_STRING);
withMetaInf.mkdirs();
org.apache.commons.io.FileUtils.copyFile(file, new File(withMetaInf, file.getName()));
}
} catch (IOException e) {
- String message = "Unable to list yang files into resource folder";
- log.warn(message, e);
- throw new MojoFailureException(message, e);
+ log.warn(String.format("Failed to generate files into root %s", yangFilesRootDir), e);
+ throw new MojoFailureException("Unable to list yang files into resource folder", e);
}
setResource(generatedYangDir, project);
* Cached legacy path, filled-in when {@link #getPath()} or {@link #getPathTowardsRoot()}
* is invoked.
*/
- private ImmutableList<QName> legacyPath;
+ private volatile ImmutableList<QName> legacyPath;
private ImmutableList<QName> getLegacyPath() {
- if (legacyPath == null) {
- legacyPath = ImmutableList.copyOf(getPathTowardsRoot()).reverse();
+ ImmutableList<QName> ret = legacyPath;
+ if (ret == null) {
+ synchronized (this) {
+ ret = legacyPath;
+ if (ret == null) {
+ ret = ImmutableList.copyOf(getPathTowardsRoot()).reverse();
+ legacyPath = ret;
+ }
+ }
}
- return legacyPath;
+ return ret;
}
/**
public static final int MAX_VALUE = 65535;
private static final String DESCRIPTION = "uint16 represents integer values between 0 and 65535, inclusively.";
- private static Uint16 INSTANCE = new Uint16();
+ private static final Uint16 INSTANCE = new Uint16();
private Uint16() {
super(BaseTypes.UINT16_QNAME, DESCRIPTION, MAX_VALUE, "");
public int hashCode() {
final int prime = 31;
int result = 1;
- result = prime * result + ((types == null) ? 0 : types.hashCode());
+ result = prime * result + types.hashCode();
return result;
}
builder.append(BaseTypes.UNION_QNAME);
builder.append(" (types=[");
for (TypeDefinition<?> td : types) {
- builder.append(", " + td.getQName().getLocalName());
+ builder.append(", " ).append(td.getQName().getLocalName());
}
- builder.append("]");
+ builder.append(']');
return builder.toString();
}
} else if (!mustConstraints.equals(other.mustConstraints)) {
return false;
}
- if (mandatory != other.mandatory) {
+ if (!mandatory.equals(other.mandatory)) {
return false;
}
if (minElements == null) {