import static com.google.common.base.Preconditions.checkArgument;
import static java.util.Objects.requireNonNull;
-import static org.opendaylight.yangtools.yang.common.SimpleDateFormatUtil.getRevisionFormat;
import com.google.common.base.Strings;
import com.google.common.collect.Interner;
import java.io.Serializable;
import java.net.URI;
import java.net.URISyntaxException;
-import java.text.ParseException;
-import java.util.Date;
import java.util.Objects;
import java.util.Optional;
import java.util.regex.Matcher;
* Local name part of QName. MUST NOT BE null.
* @return Instance of QName
*/
- public static QName create(final URI namespace, @Nullable final Date revision, final String localName) {
+ public static QName create(final URI namespace, @Nullable final Revision revision, final String localName) {
return create(QNameModule.create(namespace, revision), localName);
}
* Local name part of QName. MUST NOT BE null.
* @return Instance of QName
*/
- public static QName create(final URI namespace, final Optional<Date> revision, final String localName) {
+ public static QName create(final URI namespace, final Optional<Revision> revision, final String localName) {
return create(QNameModule.create(namespace, revision), localName);
}
* Local name part of QName. MUST NOT BE null.
* @return Instance of QName
*/
- public static QName create(final String namespace, final String localName, final Date revision) {
+ public static QName create(final String namespace, final String localName, final Revision revision) {
final URI namespaceUri = parseNamespace(namespace);
return create(QNameModule.create(namespaceUri, revision), localName);
}
*/
public static QName create(final String namespace, final String revision, final String localName) {
final URI namespaceUri = parseNamespace(namespace);
- final Date revisionDate = parseRevision(revision);
+ final Revision revisionDate = Revision.valueOf(revision);
return create(namespaceUri, revisionDate, localName);
}
*
* @return revision of the YANG module if the module has defined revision.
*/
- public Optional<Date> getRevision() {
+ public Optional<Revision> getRevision() {
return module.getRevision();
}
return create(getNamespace(), localName);
}
- @SuppressWarnings("checkstyle:illegalCatch")
- public static Date parseRevision(final String formatedDate) {
- try {
- return getRevisionFormat().parse(formatedDate);
- } catch (ParseException | RuntimeException e) {
- throw new IllegalArgumentException(
- String.format("Revision '%s'is not in a supported format", formatedDate), e);
- }
- }
-
/**
- * Formats {@link Date} representing revision to format
- * <code>YYYY-mm-dd</code>
+ * Formats {@link Revision} representing revision to format <code>YYYY-mm-dd</code>
*
* <p>
* YANG Specification defines format for <code>revision</code> as
* such as capabilities URI, YANG modules, etc.
*
* @param revision
- * Date object to formatl
+ * Date object to format
* @return String representation or null if the input was null.
*/
- public static String formattedRevision(final Optional<Date> revision) {
- return revision.map(rev -> getRevisionFormat().format(rev)).orElse(null);
+ public static String formattedRevision(final Optional<Revision> revision) {
+ return revision.map(Revision::toString).orElse(null);
}
/**
return result;
}
- final Date myRev = getRevision().orElse(null);
- final Date otherRev = other.getRevision().orElse(null);
-
- // compare nullable revision parameter
- if (myRev != null) {
- return otherRev == null ? 1 : myRev.compareTo(otherRev);
- }
-
- return otherRev == null ? 0 : -1;
+ return Revision.compare(getRevision(), other.getRevision());
}
}
import java.io.Serializable;
import java.net.URI;
import java.net.URISyntaxException;
-import java.util.Date;
import java.util.Objects;
import java.util.Optional;
+import javax.annotation.Nullable;
import org.opendaylight.yangtools.concepts.Immutable;
public final class QNameModule implements Immutable, Serializable {
private static final Interner<QNameModule> INTERNER = Interners.newWeakInterner();
- private static final long serialVersionUID = 2L;
+ private static final long serialVersionUID = 3L;
private final URI namespace;
//Nullable
- private final Date revision;
-
- //Nullable
- private transient volatile String formattedRevision;
+ private final Revision revision;
private transient int hash;
- private QNameModule(final URI namespace, final Date revision) {
+ private QNameModule(final URI namespace, final Revision revision) {
this.namespace = requireNonNull(namespace);
this.revision = revision;
}
* @param revision Module revision
* @return A new, potentially shared, QNameModule instance
*/
- public static QNameModule create(final URI namespace, final Optional<Date> revision) {
+ public static QNameModule create(final URI namespace, final Optional<Revision> revision) {
return new QNameModule(namespace, revision.orElse(null));
}
* @param revision Module revision
* @return A new, potentially shared, QNameModule instance
*/
- public static QNameModule create(final URI namespace, final Date revision) {
+ public static QNameModule create(final URI namespace, @Nullable final Revision revision) {
return new QNameModule(namespace, revision);
}
public String getFormattedRevision() {
- if (revision == null) {
- return null;
- }
-
- String ret = formattedRevision;
- if (ret == null) {
- ret = SimpleDateFormatUtil.getRevisionFormat().format(revision);
- formattedRevision = ret;
- }
-
- return ret;
+ return revision == null ? null : revision.toString();
}
/**
* @return date of the module revision which is specified as argument of
* YANG Module <b><font color="#339900">revison</font></b> keyword
*/
- // FIXME: BUG-4688: should return Optional<Revision>
- public Optional<Date> getRevision() {
+ public Optional<Revision> getRevision() {
return Optional.ofNullable(revision);
}
*
*/
URI getRevisionNamespace() throws URISyntaxException {
- final String query = revision == null ? "" : "revision=" + getFormattedRevision();
+ final String query = revision == null ? "" : "revision=" + revision.toString();
return new URI(namespace.getScheme(), namespace.getUserInfo(), namespace.getHost(), namespace.getPort(),
namespace.getPath(), query, namespace.getFragment());
}
@Override
public String toString() {
return MoreObjects.toStringHelper(QNameModule.class).omitNullValues().add("ns", getNamespace())
- .add("rev", getFormattedRevision()).toString();
+ .add("rev", revision).toString();
}
}
private Revision(final String str) {
// Since all strings conform to this format, compareTo() can be delegated to String.compareTo()
- Preconditions.checkArgument(STRING_FORMAT.matcher(str).matches(), "String '%s' does match revision format",
- str);
+ Preconditions.checkArgument(STRING_FORMAT.matcher(str).matches(),
+ "String '%s' does match revision format YYYY-MM-DD", str);
this.str = str;
}
import java.net.URI;
import java.net.URISyntaxException;
-import java.util.Date;
import java.util.Optional;
import org.junit.Test;
// compare with 1 null revision
qa = QName.create(URI.create(A), A);
- qb = QName.create(URI.create(A), QName.parseRevision(REVISION), A);
+ qb = QName.create(URI.create(A), Revision.valueOf(REVISION), A);
assertTrue(qa.compareTo(qb) < 0);
assertTrue(qb.compareTo(qa) > 0);
assertEquals(qname1, qname.withoutRevision());
assertEquals(qname1, qname2);
assertTrue(qname.isEqualWithoutRevision(qname1));
- assertNotNull(QName.formattedRevision(Optional.of(new Date())));
+ assertNotNull(QName.formattedRevision(Optional.of(Revision.valueOf("2000-01-01"))));
assertNotNull(qname.hashCode());
assertEquals(qname, qname.intern());
}
@Test
public void testQNameModule() throws URISyntaxException {
- final QNameModule qnameModule = QNameModule.create(NS, new Date());
+ final QNameModule qnameModule = QNameModule.create(NS, Revision.valueOf("2000-01-01"));
assertNotNull(qnameModule.toString());
assertNotNull(qnameModule.getRevisionNamespace());
}
import com.google.common.collect.UnmodifiableIterator;
import java.net.URI;
-import java.net.URISyntaxException;
-import java.text.ParseException;
import java.util.HashMap;
import java.util.Map;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
-import org.opendaylight.yangtools.yang.common.SimpleDateFormatUtil;
+import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
public class PathArgumentListTest {
}
@Test
- public void testPathArgument() throws URISyntaxException, ParseException {
- final QNameModule qNameModule = QNameModule.create(new URI("urn:opendaylight.test2"),
- SimpleDateFormatUtil.getRevisionFormat().parse("2015-08-08"));
+ public void testPathArgument() {
+ final QNameModule qNameModule = QNameModule.create(URI.create("urn:opendaylight.test2"),
+ Revision.valueOf("2015-08-08"));
final QName qNameRoot = QName.create(qNameModule, "root");
final QName qNameList = QName.create(qNameModule, "list");
final QName qNameLeaf = QName.create(qNameModule, "leaf-a");
*/
public class YangInstanceIdentifierTest {
- private static final QName NODENAME1 = QName.create("test", "2014-5-28", "node1");
- private static final QName NODENAME2 = QName.create("test", "2014-5-28", "node2");
- private static final QName NODENAME3 = QName.create("test", "2014-5-28", "node3");
- private static final QName NODENAME4 = QName.create("test", "2014-5-28", "node4");
- private static final QName KEY1 = QName.create("test", "2014-5-28", "key1");
- private static final QName KEY2 = QName.create("test", "2014-5-28", "key2");
- private static final QName KEY3 = QName.create("test", "2014-5-28", "key3");
+ private static final QName NODENAME1 = QName.create("test", "2014-05-28", "node1");
+ private static final QName NODENAME2 = QName.create("test", "2014-05-28", "node2");
+ private static final QName NODENAME3 = QName.create("test", "2014-05-28", "node3");
+ private static final QName NODENAME4 = QName.create("test", "2014-05-28", "node4");
+ private static final QName KEY1 = QName.create("test", "2014-05-28", "key1");
+ private static final QName KEY2 = QName.create("test", "2014-05-28", "key2");
+ private static final QName KEY3 = QName.create("test", "2014-05-28", "key3");
@Test
public void testGetLastPathArgument() {
import com.google.common.collect.ImmutableSet;
import java.io.IOException;
-import java.io.UnsupportedEncodingException;
import java.net.URI;
-import java.net.URISyntaxException;
-import java.text.ParseException;
import java.util.Optional;
import java.util.Set;
import org.junit.Before;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
-import org.opendaylight.yangtools.yang.common.SimpleDateFormatUtil;
+import org.opendaylight.yangtools.yang.common.Revision;
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;
private QName myLeafList;
@Before
- public void setUp() throws URISyntaxException, ParseException, UnsupportedEncodingException {
- bazModule = QNameModule.create(new URI("baz-namespace"), SimpleDateFormatUtil.getRevisionFormat()
- .parse("1970-01-01"));
-
+ public void setUp() {
+ bazModule = QNameModule.create(URI.create("baz-namespace"), Revision.valueOf("1970-01-01"));
myKeyedList = QName.create(bazModule, "my-keyed-list");
myKeyLeaf = QName.create(bazModule, "my-key-leaf");
myLeafList = QName.create(bazModule, "my-leaf-list");
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
+import org.opendaylight.yangtools.yang.common.Revision;
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;
@BeforeClass
public static void init() {
- fooModuleQName = QNameModule.create(URI.create("foo"), QName.parseRevision("2015-11-05"));
+ fooModuleQName = QNameModule.create(URI.create("foo"), Revision.valueOf("2015-11-05"));
rootQName = QName.create(fooModuleQName, "root");
ipAddressQName = QName.create(fooModuleQName, "ip-address");
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
+import org.opendaylight.yangtools.yang.common.Revision;
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;
@Before
public void setUp() throws Exception {
- fooModuleQName = QNameModule.create(new URI("foo"), QName.parseRevision("2016-03-22"));
+ fooModuleQName = QNameModule.create(new URI("foo"), Revision.valueOf("2016-03-22"));
schemaContext = YangParserTestUtils.parseYangResource("/bug5396/yang/foo.yang");
}
import org.opendaylight.yangtools.util.xml.UntrustedXML;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
+import org.opendaylight.yangtools.yang.common.Revision;
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;
private final SchemaContext schemaContext;
public Bug5446Test() throws Exception {
- fooModuleQName = QNameModule.create(new URI("foo"), QName.parseRevision("2015-11-05"));
+ fooModuleQName = QNameModule.create(URI.create("foo"), Revision.valueOf("2015-11-05"));
rootQName = QName.create(fooModuleQName, "root");
ipAddressQName = QName.create(fooModuleQName, "ip-address");
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
-import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import org.junit.runners.Parameterized;
import org.opendaylight.yangtools.util.xml.UntrustedXML;
import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.common.Revision;
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;
}
private static final String NAMESPACE = "urn:opendaylight:params:xml:ns:yang:controller:test";
- private static final Date REVISION = QName.parseRevision("2014-03-13");
+ private static final Revision REVISION = Revision.valueOf("2014-03-13");
static final XMLOutputFactory XML_FACTORY;
import com.google.common.collect.Iterables;
import java.net.URI;
import java.util.ArrayList;
-import java.util.Date;
import java.util.HashSet;
import java.util.List;
import org.hamcrest.CoreMatchers;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
+import org.opendaylight.yangtools.yang.common.Revision;
public class RandomPrefixTest {
static final int MAX_COUNTER = 4000;
for (int i = 0; i < MAX_COUNTER; i++) {
final String prefix = RandomPrefix.encode(i);
final URI uri = new URI("localhost:" + prefix);
- final QName qname = QName.create(QNameModule.create(uri, new Date()), "local-name");
+ final QName qname = QName.create(QNameModule.create(uri, Revision.valueOf("2000-01-01")), "local-name");
allGenerated.add(a.encodePrefix(qname.getNamespace()));
}
final RandomPrefix a = new RandomPrefix(null);
final URI uri = URI.create("localhost");
- final QName qname = QName.create(QNameModule.create(uri, new Date()), "local-name");
- final QName qname2 = QName.create(QNameModule.create(uri, new Date()), "local-name");
+ final QName qname = QName.create(QNameModule.create(uri, Revision.valueOf("2000-01-01")), "local-name");
+ final QName qname2 = QName.create(QNameModule.create(uri, Revision.valueOf("2000-01-01")), "local-name");
assertEquals(a.encodePrefix(qname.getNamespace()), a.encodePrefix(qname2.getNamespace()));
}
final RandomPrefix a = new RandomPrefix(null);
final URI uri = URI.create("localhost");
- QName qname = QName.create(uri, new Date(), "local-name");
+ QName qname = QName.create(uri, Revision.valueOf("2000-01-01"), "local-name");
assertEquals("a", a.encodePrefix(qname.getNamespace()));
- qname = QName.create(QNameModule.create(uri, new Date()), "local-name");
+ qname = QName.create(QNameModule.create(uri, Revision.valueOf("2000-01-01")), "local-name");
assertEquals("a", a.encodePrefix(qname.getNamespace()));
- qname = QName.create(QNameModule.create(URI.create("second"), new Date()), "local-name");
+ qname = QName.create(QNameModule.create(URI.create("second"), Revision.valueOf("2000-01-01")), "local-name");
assertEquals("b", a.encodePrefix(qname.getNamespace()));
}
import org.opendaylight.yangtools.util.xml.UntrustedXML;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
+import org.opendaylight.yangtools.yang.common.Revision;
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;
@Before
public void setup() {
- foobarModule = QNameModule.create(URI.create("foobar-namespace"), QName.parseRevision("2016-09-19"));
+ foobarModule = QNameModule.create(URI.create("foobar-namespace"), Revision.valueOf("2016-09-19"));
outerContainer = QName.create(foobarModule, "outer-container");
import java.net.URI;
import java.net.URISyntaxException;
import java.util.AbstractMap;
-import java.util.Date;
import java.util.HashMap;
import java.util.Map;
import java.util.Optional;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
+import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
final XMLStreamWriter writer = XML_OUTPUT_FACTORY.createXMLStreamWriter(out);
writer.writeStartElement("element");
- final QNameModule parent = QNameModule.create(URI.create("parent:uri"), new Date());
+ final QNameModule parent = QNameModule.create(URI.create("parent:uri"), Revision.valueOf("2000-01-01"));
XMLStreamWriterUtils.write(writer, null, QName.create(parent, "identity"), parent);
writer.writeEndElement();
organization "Cisco Systems, Inc.";
- revision "2014-3-13" {
+ revision "2014-03-13" {
description
"Initial revision";
}
organization "Cisco Systems, Inc.";
- revision "2014-3-13" {
+ revision "2014-03-13" {
description
"Initial revision";
}
base test-identity;
}
-}
\ No newline at end of file
+}
import com.google.common.collect.Lists;
import java.net.URI;
import java.util.ArrayList;
-import java.util.Date;
import java.util.List;
import java.util.Optional;
import org.antlr.v4.runtime.tree.TerminalNode;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
+import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.data.impl.leafref.LeafRefPathParser.IdentifierContext;
import org.opendaylight.yangtools.yang.data.impl.leafref.LeafRefPathParser.Node_identifierContext;
import org.opendaylight.yangtools.yang.data.impl.leafref.LeafRefPathParser.Path_argContext;
}
final String moduleName = moduleImport.getModuleName();
- final Optional<Date> revision = moduleImport.getRevision();
+ final Optional<Revision> revision = moduleImport.getRevision();
return schemaContext.findModule(moduleName, revision).map(Module::getQNameModule);
}
import java.util.Set;
import javax.annotation.Nullable;
import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.AugmentationNode;
import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild;
import org.opendaylight.yangtools.yang.model.api.ChoiceSchemaNode;
import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.ModuleIdentifier;
import org.opendaylight.yangtools.yang.model.api.NotificationNodeContainer;
import org.opendaylight.yangtools.yang.model.api.RpcDefinition;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
if (dataSchemaNode != null && qname != null) {
for (final DataSchemaNode dsn : dataSchemaNode) {
if (qname.isEqualWithoutRevision(dsn.getQName())) {
- if (schema == null || ModuleIdentifier.compareRevisions(schema.getQName().getRevision(),
+ if (schema == null || Revision.compare(schema.getQName().getRevision(),
dsn.getQName().getRevision()) < 0) {
schema = dsn;
}
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
-import org.opendaylight.yangtools.yang.common.SimpleDateFormatUtil;
+import org.opendaylight.yangtools.yang.common.Revision;
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;
@Before
public void setup() throws URISyntaxException, ParseException {
- bazModule = QNameModule.create(new URI("baz-namespace"), SimpleDateFormatUtil.getRevisionFormat()
- .parse("1970-01-01"));
+ bazModule = QNameModule.create(new URI("baz-namespace"), Revision.valueOf("1970-01-01"));
outerContainer = QName.create(bazModule, "outer-container");
organization "Cisco Systems, Inc.";
- revision "2014-3-13" {
+ revision "2014-03-13" {
description
"Initial revision";
}
organization "Cisco Systems, Inc.";
- revision "2014-3-13" {
+ revision "2014-03-13" {
description
"Initial revision";
}
base test-identity;
}
-}
\ No newline at end of file
+}
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
-import org.opendaylight.yangtools.yang.common.SimpleDateFormatUtil;
+import org.opendaylight.yangtools.yang.common.Revision;
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;
public static void setup() throws ParseException {
jaxenSchemaContextFactory = new JaxenSchemaContextFactory();
- fooModule = QNameModule.create(URI.create("foo-ns"),
- SimpleDateFormatUtil.getRevisionFormat().parse("2017-04-03"));
+ fooModule = QNameModule.create(URI.create("foo-ns"), Revision.valueOf("2017-04-03"));
myContainer = QName.create(fooModule, "my-container");
myList = QName.create(fooModule, "my-list");
flags = QName.create(fooModule, "flags");
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.Maps;
import java.net.URI;
-import java.text.ParseException;
import java.util.Map;
import org.jaxen.Function;
import org.junit.BeforeClass;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
-import org.opendaylight.yangtools.yang.common.SimpleDateFormatUtil;
+import org.opendaylight.yangtools.yang.common.Revision;
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;
private static QName ordinaryLeafB;
@BeforeClass
- public static void setup() throws ParseException {
+ public static void setup() {
jaxenSchemaContextFactory = new JaxenSchemaContextFactory();
- fooModule = QNameModule.create(URI.create("foo-ns"),
- SimpleDateFormatUtil.getRevisionFormat().parse("2017-04-03"));
+ fooModule = QNameModule.create(URI.create("foo-ns"), Revision.valueOf("2017-04-03"));
myContainer = QName.create(fooModule, "my-container");
myInnerContainer = QName.create(fooModule, "my-inner-container");
myList = QName.create(fooModule, "my-list");
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.Maps;
import java.net.URI;
-import java.text.ParseException;
import org.jaxen.Context;
import org.jaxen.Function;
import org.jaxen.FunctionCallException;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
-import org.opendaylight.yangtools.yang.common.SimpleDateFormatUtil;
+import org.opendaylight.yangtools.yang.common.Revision;
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;
private static QName idC2Identity;
@BeforeClass
- public static void setup() throws ParseException {
+ public static void setup() {
jaxenSchemaContextFactory = new JaxenSchemaContextFactory();
- barModule = QNameModule.create(URI.create("bar-ns"),
- SimpleDateFormatUtil.getRevisionFormat().parse("2017-04-03"));
+ barModule = QNameModule.create(URI.create("bar-ns"), Revision.valueOf("2017-04-03"));
myContainer = QName.create(barModule, "my-container");
myList = QName.create(barModule, "my-list");
keyLeaf = QName.create(barModule, "key-leaf");
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
-import org.opendaylight.yangtools.yang.common.SimpleDateFormatUtil;
+import org.opendaylight.yangtools.yang.common.Revision;
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;
public static void setup() throws ParseException {
jaxenSchemaContextFactory = new JaxenSchemaContextFactory();
- fooModule = QNameModule.create(URI.create("foo-ns"),
- SimpleDateFormatUtil.getRevisionFormat().parse("2017-04-03"));
+ fooModule = QNameModule.create(URI.create("foo-ns"), Revision.valueOf("2017-04-03"));
myContainer = QName.create(fooModule, "my-container");
alarm = QName.create(fooModule, "alarm");
severity = QName.create(fooModule, "severity");
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
-import org.opendaylight.yangtools.yang.common.SimpleDateFormatUtil;
+import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.data.api.schema.xpath.XPathDocument;
}
private void initQNames() throws URISyntaxException, ParseException {
- this.moduleQName = QNameModule.create(new URI("urn:opendaylight.test2"),
- SimpleDateFormatUtil.getRevisionFormat().parse("2015-08-08"));
+ this.moduleQName = QNameModule.create(new URI("urn:opendaylight.test2"), Revision.valueOf("2015-08-08"));
this.rootQName = QName.create(moduleQName, "root");
this.listAQName = QName.create(moduleQName, "list-a");
this.listBQName = QName.create(moduleQName, "list-b");
import java.util.Deque;
import java.util.List;
import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.model.api.ChoiceCaseNode;
import org.opendaylight.yangtools.yang.model.api.ChoiceSchemaNode;
import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.ModuleIdentifier;
public final class ParserStreamUtils {
final QName childQName = childNode.getQName();
if (childQName.getLocalName().equals(childName) && childQName.getNamespace().equals(namespace)) {
- if (potentialChildNode == null || ModuleIdentifier.compareRevisions(childQName.getRevision(),
+ if (potentialChildNode == null || Revision.compare(childQName.getRevision(),
potentialChildNode.getQName().getRevision()) > 0) {
potentialChildNode = childNode;
}
organization "Cisco Systems, Inc.";
- revision "2014-3-13" {
+ revision "2014-03-13" {
description
"Initial revision";
}
type string;
}
}
-}
\ No newline at end of file
+}
organization "Cisco Systems, Inc.";
- revision "2014-3-13" {
+ revision "2014-03-13" {
description
"Initial revision";
}
type string;
}
}
-}
\ No newline at end of file
+}
package org.opendaylight.yangtools.yang.model.api;
import java.net.URI;
-import java.util.Date;
import java.util.List;
import java.util.Optional;
import java.util.Set;
import javax.annotation.concurrent.Immutable;
import org.opendaylight.yangtools.concepts.SemVer;
import org.opendaylight.yangtools.yang.common.QNameModule;
+import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.common.YangVersion;
/**
* YANG {@link Module <b><font color="#339900">revison</font></b>}
* keyword
*/
- // FIXME: BUG-4688: should return Optional<Revision>
- default Optional<Date> getRevision() {
+ default Optional<Revision> getRevision() {
return getQNameModule().getRevision();
}
*/
package org.opendaylight.yangtools.yang.model.api;
-import java.util.Date;
import java.util.Optional;
+import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
/**
* YANG {@link Module <b><font color="#339900">revison</font></b>}
* keyword
*/
- // FIXME: BUG-4688: should return Optional<Revision>
- Optional<Date> getRevision();
-
- static int compareRevisions(final Optional<Date> first, final Optional<Date> second) {
- if (!first.isPresent()) {
- return second.isPresent() ? -1 : 0;
- }
- return second.isPresent() ? first.get().compareTo(second.get()) : 1;
- }
+ Optional<Revision> getRevision();
}
*/
package org.opendaylight.yangtools.yang.model.api;
-import java.util.Date;
import java.util.Optional;
import org.opendaylight.yangtools.concepts.SemVer;
+import org.opendaylight.yangtools.yang.common.Revision;
/**
* Interface describing YANG 'import' statement.
*
* @return Revision of module to import
*/
- Optional<Date> getRevision();
+ Optional<Revision> getRevision();
/**
* Returns the semantic version to import.
package org.opendaylight.yangtools.yang.model.api;
import java.net.URI;
-import java.util.Date;
+import java.util.Optional;
+import org.opendaylight.yangtools.yang.common.Revision;
public interface NamespaceRevisionAware {
URI getNamespace();
- Date getRevision();
+ Optional<Revision> getRevision();
}
import com.google.common.collect.Sets;
import java.net.URI;
-import java.util.Date;
import java.util.Optional;
import java.util.Set;
import javax.annotation.Nullable;
import javax.annotation.concurrent.Immutable;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
+import org.opendaylight.yangtools.yang.common.Revision;
/**
* The interface represents static view of compiled yang files,
* @param name
* string with the module name
* @param revision
- * date of the module revision, may be null
+ * date of the module revision
* @return module instance which has name and revision the same as are the values specified in parameters
* <code>name</code> and <code>revision</code>.
*/
- Optional<Module> findModule(String name, @Nullable Date revision);
+ Optional<Module> findModule(String name, Optional<Revision> revision);
/**
* Returns module instance (from the context) with concrete name and revision date.
* @return module instance which has name and revision the same as are the values specified in parameters
* <code>name</code> and <code>revision</code>.
*/
- default Optional<Module> findModule(final String name, final Optional<Date> revision) {
- return findModule(name, revision.orElse(null));
+ default Optional<Module> findModule(final String name, @Nullable final Revision revision) {
+ return findModule(name, Optional.ofNullable(revision));
}
default Optional<Module> findModule(final URI namespace) {
return findModule(QNameModule.create(namespace));
}
- default Optional<Module> findModule(final URI namespace, @Nullable final Date revision) {
+ default Optional<Module> findModule(final URI namespace, @Nullable final Revision revision) {
+ return findModule(QNameModule.create(namespace, revision));
+ }
+
+ default Optional<Module> findModule(final URI namespace, final Optional<Revision> revision) {
return findModule(QNameModule.create(namespace, revision));
}
*/
package org.opendaylight.yangtools.yang.model.api.stmt;
-import java.util.Date;
-
+import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
-public interface RevisionDateStatement extends DeclaredStatement<Date> {
+public interface RevisionDateStatement extends DeclaredStatement<Revision> {
- Date getDate();
+ Revision getDate();
}
*/
package org.opendaylight.yangtools.yang.model.api.stmt;
-import java.util.Date;
import javax.annotation.Nonnull;
+import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
-public interface RevisionStatement extends DeclaredStatement<Date>, DocumentationGroup {
+public interface RevisionStatement extends DeclaredStatement<Revision>, DocumentationGroup {
- @Nonnull Date getDate();
+ @Nonnull Revision getDate();
}
import com.google.common.primitives.UnsignedInteger;
import java.net.URI;
import java.util.Collection;
-import java.util.Date;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import javax.annotation.Nullable;
import javax.annotation.concurrent.NotThreadSafe;
import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.common.YangVersion;
import org.opendaylight.yangtools.yang.model.api.ActionDefinition;
import org.opendaylight.yangtools.yang.model.api.AnyDataSchemaNode;
}
}
- private void emitRevision(final Date date) {
+ private void emitRevision(final Revision date) {
if (date != null) {
super.writer.startRevisionNode(date);
}
}
- private void emitRevisionDateNode(final Date date) {
+ private void emitRevisionDateNode(final Revision date) {
super.writer.startRevisionDateNode(date);
super.writer.endNode();
}
import com.google.common.primitives.UnsignedInteger;
import java.net.URI;
import java.util.Collection;
-import java.util.Date;
import java.util.Iterator;
import java.util.List;
import javax.annotation.concurrent.NotThreadSafe;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.common.SimpleDateFormatUtil;
+import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.model.api.RevisionAwareXPath;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.Status;
}
@Override
- public void startRevisionNode(final Date date) {
+ public void startRevisionNode(final Revision date) {
writer.startStatement(YangStmtMapping.REVISION);
- writer.writeArgument(SimpleDateFormatUtil.getRevisionFormat().format(date));
+ writer.writeArgument(date.toString());
}
@Override
}
@Override
- public void startRevisionDateNode(final Date date) {
+ public void startRevisionDateNode(final Revision date) {
writer.startStatement(YangStmtMapping.REVISION_DATE);
- writer.writeArgument(SimpleDateFormatUtil.getRevisionFormat().format(date));
+ writer.writeArgument(date.toString());
}
@Override
import com.google.common.primitives.UnsignedInteger;
import java.net.URI;
-import java.util.Date;
import java.util.List;
import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.model.api.RevisionAwareXPath;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.Status;
void startTypedefNode(QName qName);
- void startRevisionNode(Date date);
+ void startRevisionNode(Revision date);
void startDefaultNode(String string);
void startReferenceNode(String input);
- void startRevisionDateNode(Date date);
+ void startRevisionDateNode(Revision date);
void startImportNode(String moduleName);
import com.google.common.collect.HashBiMap;
import java.io.OutputStream;
import java.net.URI;
-import java.util.Date;
import java.util.Map;
import java.util.Optional;
import javax.xml.stream.XMLOutputFactory;
import javax.xml.stream.XMLStreamException;
import javax.xml.stream.XMLStreamWriter;
-import org.opendaylight.yangtools.yang.common.SimpleDateFormatUtil;
+import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.common.YangConstants;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.ModuleImport;
* Revision of module or submodule
* @return well-formed file name of YIN file as defined in RFC6020.
*/
- public static String wellFormedYinName(final String name, final Optional<Date> revision) {
- return !revision.isPresent() ? wellFormedYinName(name, (String) null) :
- wellFormedYinName(name, SimpleDateFormatUtil.getRevisionFormat().format(revision.get()));
+ public static String wellFormedYinName(final String name, final Optional<Revision> revision) {
+ return wellFormedYinName(name, revision.map(Revision::toString).orElse(null));
}
/**
import java.io.ByteArrayOutputStream;
import java.io.OutputStream;
import org.junit.Test;
-import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.model.export.YinExportUtils;
final OutputStream byteArrayOutputStream = new ByteArrayOutputStream();
final BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(byteArrayOutputStream);
- final Module fooModule = schemaContext.findModule("foo", QName.parseRevision("2017-02-28")).get();
+ final Module fooModule = schemaContext.findModule("foo", Revision.valueOf("2017-02-28")).get();
YinExportUtils.writeModuleToOutputStream(schemaContext, fooModule, bufferedOutputStream);
final String output = byteArrayOutputStream.toString();
final OutputStream byteArrayOutputStream = new ByteArrayOutputStream();
final BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(byteArrayOutputStream);
- final Module barModule = schemaContext.findModule("bar", QName.parseRevision("2017-02-28")).get();
+ final Module barModule = schemaContext.findModule("bar", Revision.valueOf("2017-02-28")).get();
YinExportUtils.writeModuleToOutputStream(schemaContext, barModule, bufferedOutputStream);
final String output = byteArrayOutputStream.toString();
import java.io.IOException;
import java.io.InputStream;
import java.io.StringWriter;
-import java.util.Date;
import java.util.Optional;
import javax.xml.transform.OutputKeys;
import javax.xml.transform.Transformer;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
import org.opendaylight.yangtools.util.xml.UntrustedXML;
-import org.opendaylight.yangtools.yang.common.SimpleDateFormatUtil;
+import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.common.YangConstants;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.w3c.dom.Document;
}
public static Document loadDocument(final String prefix, final Module module) throws IOException, SAXException {
- final Optional<Date> rev = module.getRevision();
- final String fileName = !rev.isPresent() ? module.getName()
- : module.getName() + '@' + SimpleDateFormatUtil.getRevisionFormat().format(rev.get());
+ final Optional<Revision> rev = module.getRevision();
+ final String fileName = !rev.isPresent() ? module.getName() : module.getName() + '@' + rev.get().toString();
return loadDocument(prefix + '/' + fileName + YangConstants.RFC6020_YIN_FILE_EXTENSION);
}
*/
package org.opendaylight.yangtools.yang.model.immutable;
-import java.util.Date;
import java.util.Optional;
import org.immutables.value.Value;
+import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
abstract class AbstractSchemaContext extends CommonContainerSchemaNode implements SchemaContext {
@Override
- public Optional<Module> findModule(final String name, final Date revision) {
+ public Optional<Module> findModule(final String name, final Optional<Revision> revision) {
throw new UnsupportedOperationException("Not implemented");
}
}
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
-import java.util.Date;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.List;
-import java.util.Objects;
import java.util.Optional;
import java.util.Set;
import java.util.TreeSet;
import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.model.api.AugmentationSchema;
import org.opendaylight.yangtools.yang.model.api.ConstraintDefinition;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ExtensionDefinition;
import org.opendaylight.yangtools.yang.model.api.GroupingDefinition;
import org.opendaylight.yangtools.yang.model.api.Module;
-import org.opendaylight.yangtools.yang.model.api.ModuleIdentifier;
import org.opendaylight.yangtools.yang.model.api.NotificationDefinition;
import org.opendaylight.yangtools.yang.model.api.RpcDefinition;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.model.api.UsesNode;
public abstract class AbstractSchemaContext implements SchemaContext {
- protected static final Comparator<Module> REVISION_COMPARATOR = (first, second) -> {
- return ModuleIdentifier.compareRevisions(first.getRevision(), second.getRevision());
- };
+ protected static final Comparator<Module> REVISION_COMPARATOR =
+ (first, second) -> Revision.compare(first.getRevision(), second.getRevision());
protected static final TreeSet<Module> createModuleSet() {
return new TreeSet<>(REVISION_COMPARATOR);
@Override
- public Optional<Module> findModule(final String name, final Date revision) {
+ public Optional<Module> findModule(final String name, final Optional<Revision> revision) {
for (final Module module : getNameToModules().get(name)) {
- if (Objects.equals(revision, module.getRevision().orElse(null))) {
+ if (revision.equals(module.getRevision())) {
return Optional.of(module);
}
}
import java.net.URI;
import java.util.Collection;
import java.util.Collections;
-import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.TreeMap;
import java.util.function.Function;
import javax.annotation.concurrent.Immutable;
+import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.ModuleIdentifier;
import org.opendaylight.yangtools.yang.model.api.ModuleImport;
for (Module module : baseModules) {
for (ModuleImport moduleImport : module.getImports()) {
- Optional<Date> revisionDate = moduleImport.getRevision();
+ Optional<Revision> revisionDate = moduleImport.getRevision();
if (!revisionDate.isPresent()) {
revisionDate = nameToModulesAll.get(moduleImport.getModuleName()).last().getRevision();
}
public static final class ModuleId {
private final String name;
- private final Date rev;
+ private final Revision rev;
- public ModuleId(final String name, final Optional<Date> rev) {
+ public ModuleId(final String name, final Optional<Revision> rev) {
Preconditions.checkArgument(!Strings.isNullOrEmpty(name),
"No module dependency name given. Nothing to do.");
this.name = name;
return name;
}
- public Optional<Date> getRev() {
+ public Optional<Revision> getRev() {
return Optional.ofNullable(rev);
}
import com.google.common.collect.Table;
import java.net.URI;
import java.util.Collection;
-import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import org.opendaylight.yangtools.util.TopologicalSort;
import org.opendaylight.yangtools.util.TopologicalSort.Node;
import org.opendaylight.yangtools.util.TopologicalSort.NodeImpl;
-import org.opendaylight.yangtools.yang.common.SimpleDateFormatUtil;
+import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.common.YangVersion;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.ModuleImport;
}
private static List<Node> sortInternal(final Iterable<Module> modules) {
- final Table<String, Optional<Date>, ModuleNodeImpl> moduleGraph = createModuleGraph(modules);
+ final Table<String, Optional<Revision>, ModuleNodeImpl> moduleGraph = createModuleGraph(modules);
return TopologicalSort.sort(new HashSet<>(moduleGraph.values()));
}
- private static Table<String, Optional<Date>, ModuleNodeImpl> createModuleGraph(final Iterable<Module> builders) {
- final Table<String, Optional<Date>, ModuleNodeImpl> moduleGraph = HashBasedTable.create();
+ private static Table<String, Optional<Revision>, ModuleNodeImpl> createModuleGraph(
+ final Iterable<Module> builders) {
+ final Table<String, Optional<Revision>, ModuleNodeImpl> moduleGraph = HashBasedTable.create();
processModules(moduleGraph, builders);
processDependencies(moduleGraph, builders);
/**
* Extract module:revision from modules.
*/
- private static void processDependencies(final Table<String, Optional<Date>, ModuleNodeImpl> moduleGraph,
+ private static void processDependencies(final Table<String, Optional<Revision>, ModuleNodeImpl> moduleGraph,
final Iterable<Module> mmbs) {
final Map<URI, Module> allNS = new HashMap<>();
// Create edges in graph
for (final Module module : mmbs) {
- final Map<String, Optional<Date>> imported = new HashMap<>();
+ final Map<String, Optional<Revision>> imported = new HashMap<>();
final String fromName = module.getName();
final URI ns = module.getNamespace();
- final Optional<Date> fromRevision = module.getRevision();
+ final Optional<Revision> fromRevision = module.getRevision();
// check for existence of module with same namespace
final Module prev = allNS.putIfAbsent(ns, module);
// no need to check if other Type of object, check is performed in process modules
for (final ModuleImport imprt : module.getImports()) {
final String toName = imprt.getModuleName();
- final Optional<Date> toRevision = imprt.getRevision();
+ final Optional<Revision> toRevision = imprt.getRevision();
final ModuleNodeImpl from = moduleGraph.get(fromName, fromRevision);
final ModuleNodeImpl to = getModuleByNameAndRevision(moduleGraph, fromName, fromRevision, toName,
* revisions then throw exception
*/
if (module.getYangVersion() == YangVersion.VERSION_1) {
- final Optional<Date> impRevision = imported.get(toName);
+ final Optional<Revision> impRevision = imported.get(toName);
if (impRevision != null && impRevision.isPresent() && !impRevision.equals(toRevision)
&& toRevision.isPresent()) {
throw new IllegalArgumentException(String.format(
* Get imported module by its name and revision from moduleGraph.
*/
private static ModuleNodeImpl getModuleByNameAndRevision(
- final Table<String, Optional<Date>, ModuleNodeImpl> moduleGraph, final String fromName,
- final Optional<Date> fromRevision, final String toName, final Optional<Date> toRevision) {
+ final Table<String, Optional<Revision>, ModuleNodeImpl> moduleGraph, final String fromName,
+ final Optional<Revision> fromRevision, final String toName, final Optional<Revision> toRevision) {
final ModuleNodeImpl exact = moduleGraph.get(toName, toRevision);
if (exact != null) {
// If revision is not specified in import, but module exists with different revisions, take first one
if (toRevision == null) {
- final Map<Optional<Date>, ModuleNodeImpl> modulerevs = moduleGraph.row(toName);
+ final Map<Optional<Revision>, ModuleNodeImpl> modulerevs = moduleGraph.row(toName);
if (!modulerevs.isEmpty()) {
final ModuleNodeImpl first = modulerevs.values().iterator().next();
/**
* Extract dependencies from modules to fill dependency graph.
*/
- private static void processModules(final Table<String, Optional<Date>, ModuleNodeImpl> moduleGraph,
+ private static void processModules(final Table<String, Optional<Revision>, ModuleNodeImpl> moduleGraph,
final Iterable<Module> modules) {
// Process nodes
for (final Module momb : modules) {
final String name = momb.getName();
- final Optional<Date> rev = momb.getRevision();
- final Map<Optional<Date>, ModuleNodeImpl> revs = moduleGraph.row(name);
+ final Optional<Revision> rev = momb.getRevision();
+ final Map<Optional<Revision>, ModuleNodeImpl> revs = moduleGraph.row(name);
if (revs.containsKey(rev)) {
throw new IllegalArgumentException(String.format("Module:%s with revision:%s declared twice", name,
formatRevDate(rev)));
}
}
- private static String formatRevDate(final Optional<Date> rev) {
- return rev.map(revision -> SimpleDateFormatUtil.getRevisionFormat().format(revision)).orElse("default");
+ private static String formatRevDate(final Optional<Revision> rev) {
+ return rev.map(Revision::toString).orElse("default");
}
private static final class ModuleNodeImpl extends NodeImpl {
private final String name;
- private final Date revision;
+ private final Revision revision;
private final Module originalObject;
- ModuleNodeImpl(final String name, final Date revision, final Module module) {
+ ModuleNodeImpl(final String name, final Revision revision, final Module module) {
this.name = name;
this.revision = revision;
this.originalObject = module;
return name;
}
- Optional<Date> getRevision() {
+ Optional<Revision> getRevision() {
return Optional.ofNullable(revision);
}
import static com.google.common.base.Preconditions.checkNotNull;
import com.google.common.annotations.Beta;
-import java.util.Date;
import java.util.Optional;
+import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.model.api.ModuleIdentifier;
/**
@Deprecated
@Beta
public final class ModuleIdentifierImpl implements ModuleIdentifier {
- private final Date revision;
+ private final Revision revision;
private final String name;
- private ModuleIdentifierImpl(final String name, final Optional<Date> revision) {
+ private ModuleIdentifierImpl(final String name, final Optional<Revision> revision) {
this.name = checkNotNull(name);
this.revision = revision.orElse(null);
}
- public static ModuleIdentifier create(final String name, final Optional<Date> revision) {
+ public static ModuleIdentifier create(final String name, final Optional<Revision> revision) {
return new ModuleIdentifierImpl(name, revision);
}
@Override
- public Optional<Date> getRevision() {
+ public Optional<Revision> getRevision() {
return Optional.ofNullable(revision);
}
import java.net.URI;
import java.util.Arrays;
import java.util.Collections;
-import java.util.Date;
import java.util.HashSet;
import java.util.List;
import java.util.Optional;
import org.opendaylight.yangtools.concepts.SemVer;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
+import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ExtensionDefinition;
public class SchemaContextProxyTest {
private static final URI NAMESPACE = URI.create("urn:opendaylight:params:xml:ns:yang:controller:config");
- private static final Date REVISION = QName.parseRevision("2015-01-01");
- private static final Date REVISION2 = QName.parseRevision("2015-01-15");
+ private static final Revision REVISION = Revision.valueOf("2015-01-01");
+ private static final Revision REVISION2 = Revision.valueOf("2015-01-15");
private static final String CONFIG_NAME = "config";
private static final String ROOT_NAME = "root";
*/
@Test
public void testBasicNullRevision() throws Exception {
- final Module moduleConfig = mockModule(CONFIG_NAME, QName.parseRevision("2013-04-05"));
- final Module module2 = mockModule(MODULE2_NAME, QName.parseRevision("2014-06-17"));
+ final Module moduleConfig = mockModule(CONFIG_NAME, Revision.valueOf("2013-04-05"));
+ final Module module2 = mockModule(MODULE2_NAME, Revision.valueOf("2014-06-17"));
final Module module20 = mockModule(MODULE2_NAME, null);
- final Module module3 = mockModule(MODULE3_NAME, QName.parseRevision("2014-06-12"));
+ final Module module3 = mockModule(MODULE3_NAME, Revision.valueOf("2014-06-12"));
final Module module30 = mockModule(MODULE3_NAME, null);
mockModuleImport(module20, moduleConfig);
Module moduleConfig = mockModule(CONFIG_NAME);
Module module2 = mockModule(MODULE2_NAME);
Module module3 = mockModule(MODULE3_NAME);
- Module module4 = mockModule(MODULE3_NAME, QName.parseRevision("2015-10-10"));
+ Module module4 = mockModule(MODULE3_NAME, Revision.valueOf("2015-10-10"));
mockModuleImport(module2, moduleConfig);
mockModuleImport(module3, module2, moduleConfig);
}
@Override
- public Optional<Date> getRevision() {
+ public Optional<Revision> getRevision() {
return module.getRevision();
}
}
//mock module with revision
- private static Module mockModule(final String name, final Date rev) {
+ private static Module mockModule(final String name, final Revision rev) {
final Module mod = mockModule(name);
import java.net.URI;
import java.net.URISyntaxException;
-import java.util.Date;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.Status;
final URI uriB1 = new URI("some:uriB1");
final URI uriB2 = new URI("some:uriB2");
- QName qnameA1 = QName.create(uriA1, new Date(6000000), "some nameA1");
- QName qnameA2 = QName.create(uriA2, new Date(7000000), "some nameA2");
+ QName qnameA1 = QName.create(uriA1, Revision.valueOf("2000-01-01"), "some nameA1");
+ QName qnameA2 = QName.create(uriA2, Revision.valueOf("2002-01-01"), "some nameA2");
SchemaPath schemaPathA = SchemaPath.create(true, qnameA1, qnameA2);
- final QName qnameB1 = QName.create(uriB1, new Date(6000000), "some nameB1");
- final QName qnameB2 = QName.create(uriB2, new Date(7000000), "some nameB2");
+ final QName qnameB1 = QName.create(uriB1, Revision.valueOf("2000-01-01"), "some nameB1");
+ final QName qnameB2 = QName.create(uriB2, Revision.valueOf("2002-01-01"), "some nameB2");
final SchemaPath schemaPathB = SchemaPath.create(true, qnameB1, qnameB2);
BitImpl biA = new BitImpl(schemaPathA, 55L, "description", "reference", Status.CURRENT, emptyList());
import com.google.common.base.Strings;
import com.google.common.collect.ImmutableSet;
import java.io.IOException;
-import java.util.Date;
import java.util.HashSet;
import java.util.Objects;
import java.util.Optional;
import org.opendaylight.yangtools.antlrv4.code.gen.YangStatementParser.StatementContext;
import org.opendaylight.yangtools.concepts.SemVer;
import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.model.api.ModuleImport;
import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
import org.opendaylight.yangtools.yang.model.parser.api.YangSyntaxErrorException;
private final String name;
private final String formattedRevision;
- private final Date revision;
+ private final Revision revision;
private final Optional<SemVer> semVer;
private final ImmutableSet<ModuleImport> submoduleIncludes;
private final ImmutableSet<ModuleImport> moduleImports;
final Optional<SemVer> semVer) {
this.name = name;
this.formattedRevision = formattedRevision;
- this.revision = formattedRevision == null ? null : QName
- .parseRevision(formattedRevision);
+ this.revision = formattedRevision == null ? null : Revision.valueOf(formattedRevision);
this.moduleImports = imports;
this.submoduleIncludes = includes;
this.dependencies = ImmutableSet.<ModuleImport>builder()
*
* @return revision
*/
- Date getRevision() {
+ Revision getRevision() {
return revision;
}
final String revisionDateStr = getRevisionDateString(subStatementContext, sourceName);
final String importedModuleName = Utils.stringFromStringContext(subStatementContext.argument(),
getReference(sourceName, subStatementContext));
- final Date revisionDate = revisionDateStr == null ? null : QName.parseRevision(revisionDateStr);
+ final Revision revisionDate = revisionDateStr == null ? null : Revision.valueOf(revisionDateStr);
final SemVer importSemVer = findSemanticVersion(subStatementContext, sourceName);
result.add(new ModuleImportImpl(importedModuleName, revisionDate, importSemVer));
}
final String revisionDateStr = getRevisionDateString(subStatementContext, sourceName);
final String IncludeModuleName = Utils.stringFromStringContext(subStatementContext.argument(),
getReference(sourceName, subStatementContext));
- final Date revisionDate = revisionDateStr == null ? null : QName.parseRevision(revisionDateStr);
+ final Revision revisionDate = revisionDateStr == null ? null : Revision.valueOf(revisionDateStr);
result.add(new ModuleImportImpl(IncludeModuleName, revisionDate));
}
}
*/
private static final class ModuleImportImpl implements ModuleImport {
- private final Date revision;
+ private final Revision revision;
private final SemVer semVer;
private final String name;
- ModuleImportImpl(final String moduleName, final Date revision) {
+ ModuleImportImpl(final String moduleName, final Revision revision) {
this(moduleName, revision, null);
}
- ModuleImportImpl(final String moduleName, @Nullable final Date revision, @Nullable final SemVer semVer) {
+ ModuleImportImpl(final String moduleName, @Nullable final Revision revision, @Nullable final SemVer semVer) {
this.name = requireNonNull(moduleName, "Module name must not be null.");
this.revision = revision;
this.semVer = semVer;
}
@Override
- public Optional<Date> getRevision() {
+ public Optional<Revision> getRevision() {
return Optional.ofNullable(revision);
}
import com.google.common.collect.Multimap;
import java.util.ArrayList;
import java.util.Collection;
-import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
import org.opendaylight.yangtools.concepts.SemVer;
+import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.model.api.ModuleImport;
import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
import org.opendaylight.yangtools.yang.parser.impl.util.YangModelDependencyInfo;
}
@Override
- public Optional<Date> getRevision() {
+ public Optional<Revision> getRevision() {
return Optional.empty();
}
import com.google.common.collect.TreeBasedTable;
import java.util.ArrayList;
import java.util.Collection;
-import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import org.opendaylight.yangtools.util.RecursiveObjectLeaker;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
+import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.common.YangVersion;
import org.opendaylight.yangtools.yang.model.api.ModuleIdentifier;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
Preconditions.checkState(currentPhase == ModelProcessingPhase.SOURCE_PRE_LINKAGE,
"Required library sources can be collected only in ModelProcessingPhase.SOURCE_PRE_LINKAGE phase,"
+ " but current phase was %s", currentPhase);
- final TreeBasedTable<String, Optional<Date>, SourceSpecificContext> libSourcesTable = TreeBasedTable.create(
- String::compareTo, ModuleIdentifier::compareRevisions);
+ final TreeBasedTable<String, Optional<Revision>, SourceSpecificContext> libSourcesTable = TreeBasedTable.create(
+ String::compareTo, Revision::compare);
for (final SourceSpecificContext libSource : libSources) {
final ModuleIdentifier libSourceIdentifier = Preconditions.checkNotNull(libSource.getRootIdentifier());
libSourcesTable.put(libSourceIdentifier.getName(), libSourceIdentifier.getRevision(), libSource);
}
private void collectRequiredSourcesFromLib(
- final TreeBasedTable<String, Optional<Date>, SourceSpecificContext> libSourcesTable,
+ final TreeBasedTable<String, Optional<Revision>, SourceSpecificContext> libSourcesTable,
final Set<SourceSpecificContext> requiredLibs, final SourceSpecificContext source) {
for (final SourceIdentifier requiredSource : source.getRequiredSources()) {
final SourceSpecificContext libSource = getRequiredLibSource(requiredSource, libSourcesTable);
}
private static SourceSpecificContext getRequiredLibSource(final SourceIdentifier requiredSource,
- final TreeBasedTable<String, Optional<Date>, SourceSpecificContext> libSourcesTable) {
+ final TreeBasedTable<String, Optional<Revision>, SourceSpecificContext> libSourcesTable) {
return requiredSource.getRevision() == null ? getLatestRevision(libSourcesTable.row(requiredSource.getName()))
: libSourcesTable.get(requiredSource.getName(),
- Optional.of(QName.parseRevision(requiredSource.getRevision())));
+ Optional.of(Revision.valueOf(requiredSource.getRevision())));
}
- private static SourceSpecificContext getLatestRevision(final SortedMap<Optional<Date>,
+ private static SourceSpecificContext getLatestRevision(final SortedMap<Optional<Revision>,
SourceSpecificContext> sourceMap) {
return sourceMap != null && !sourceMap.isEmpty() ? sourceMap.get(sourceMap.lastKey()) : null;
}
import com.google.common.base.Verify;
import java.net.URI;
import java.util.Collection;
-import java.util.Date;
import java.util.Optional;
import org.opendaylight.yangtools.concepts.SemVer;
-import org.opendaylight.yangtools.yang.common.SimpleDateFormatUtil;
+import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.model.api.ModuleIdentifier;
import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
final ModelActionBuilder importAction = stmt.newInferenceAction(SOURCE_LINKAGE);
final Prerequisite<StmtContext<?, ?, ?>> imported;
final String moduleName = stmt.getStatementArgument();
- final Date revision = firstAttributeOf(stmt.declaredSubstatements(), RevisionDateStatement.class);
+ final Revision revision = firstAttributeOf(stmt.declaredSubstatements(), RevisionDateStatement.class);
if (revision == null) {
imported = importAction.requiresCtx(stmt, ModuleNamespace.class,
NamespaceKeyCriterion.latestRevisionModule(moduleName), SOURCE_LINKAGE);
}
static SourceIdentifier getImportedSourceIdentifier(final StmtContext<String, ImportStatement, ?> stmt) {
- final StmtContext<Date, ?, ?> revision = findFirstDeclaredSubstatement(stmt, RevisionDateStatement.class);
+ final StmtContext<Revision, ?, ?> revision = findFirstDeclaredSubstatement(stmt,
+ RevisionDateStatement.class);
return revision == null ? RevisionSourceIdentifier.create(stmt.getStatementArgument())
: RevisionSourceIdentifier.create(stmt.getStatementArgument(), revision.rawStatementArgument());
}
private static SemVerSourceIdentifier createSemVerModuleIdentifier(
final ModuleIdentifier importedModuleIdentifier, final SemVer semVer) {
- final String formattedRevision = importedModuleIdentifier.getRevision().map(
- date -> SimpleDateFormatUtil.getRevisionFormat().format(date))
+ final String formattedRevision = importedModuleIdentifier.getRevision().map(Revision::toString)
.orElse(null);
return SemVerSourceIdentifier.create(importedModuleIdentifier.getName(), formattedRevision, semVer);
}
import static org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils.findFirstDeclaredSubstatement;
import java.util.Collection;
-import java.util.Date;
import java.util.Optional;
import javax.annotation.Nonnull;
+import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.DescriptionStatement;
@Override
public void onPreLinkageDeclared(
final Mutable<String, IncludeStatement, EffectiveStatement<String, IncludeStatement>> stmt) {
- final StmtContext<Date, ?, ?> revision = findFirstDeclaredSubstatement(stmt, RevisionDateStatement.class);
+ final StmtContext<Revision, ?, ?> revision = findFirstDeclaredSubstatement(stmt,
+ RevisionDateStatement.class);
stmt.addRequiredSource(revision == null ? RevisionSourceIdentifier.create(stmt.getStatementArgument())
: RevisionSourceIdentifier.create(stmt.getStatementArgument(), revision.rawStatementArgument()));
}
public void onLinkageDeclared(
final Mutable<String, IncludeStatement, EffectiveStatement<String, IncludeStatement>> stmt) {
final String submoduleName = stmt.getStatementArgument();
- final StmtContext<Date, ?, ?> revision = findFirstDeclaredSubstatement(stmt,
+ final StmtContext<Revision, ?, ?> revision = findFirstDeclaredSubstatement(stmt,
RevisionDateStatement.class);
final ModelActionBuilder includeAction = stmt.newInferenceAction(SOURCE_LINKAGE);
import static org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils.firstAttributeOf;
import java.net.URI;
-import java.util.Date;
import java.util.Optional;
import org.opendaylight.yangtools.concepts.SemVer;
import org.opendaylight.yangtools.yang.common.QNameModule;
+import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.model.api.ModuleIdentifier;
import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
stmt.addContext(PreLinkageModuleNamespace.class, moduleName, stmt);
- final Optional<Date> revisionDate = Optional.ofNullable(StmtContextUtils.getLatestRevision(
- stmt.declaredSubstatements()));
+ final Optional<Revision> revisionDate = StmtContextUtils.getLatestRevision(stmt.declaredSubstatements());
final QNameModule qNameModule = QNameModule.create(moduleNs, revisionDate.orElse(null)).intern();
stmt.addToNs(ModuleCtxToModuleQName.class, stmt, qNameModule);
SourceException.throwIf(!moduleNs.isPresent(), stmt.getStatementSourceReference(),
"Namespace of the module [%s] is missing", stmt.getStatementArgument());
- final Optional<Date> revisionDate = Optional.ofNullable(StmtContextUtils.getLatestRevision(
- stmt.declaredSubstatements()));
+ final Optional<Revision> revisionDate = StmtContextUtils.getLatestRevision(stmt.declaredSubstatements());
final QNameModule qNameModule = QNameModule.create(moduleNs.get(), revisionDate.orElse(null)).intern();
final StmtContext<?, ModuleStatement, EffectiveStatement<String, ModuleStatement>> possibleDuplicateModule =
stmt.getFromNamespace(NamespaceToModule.class, qNameModule);
*/
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
-import java.text.ParseException;
-import java.util.Date;
-import org.opendaylight.yangtools.yang.common.SimpleDateFormatUtil;
+import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.RevisionDateStatement;
import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.RevisionDateEffectiveStatementImpl;
-public class RevisionDateStatementImpl extends AbstractDeclaredStatement<Date> implements RevisionDateStatement {
+public class RevisionDateStatementImpl extends AbstractDeclaredStatement<Revision> implements RevisionDateStatement {
private static final SubstatementValidator SUBSTATEMENT_VALIDATOR =
SubstatementValidator.builder(YangStmtMapping.REVISION_DATE).build();
- protected RevisionDateStatementImpl(final StmtContext<Date, RevisionDateStatement, ?> context) {
+ protected RevisionDateStatementImpl(final StmtContext<Revision, RevisionDateStatement, ?> context) {
super(context);
}
- public static class Definition
- extends
- AbstractStatementSupport<Date, RevisionDateStatement, EffectiveStatement<Date, RevisionDateStatement>> {
+ public static class Definition extends AbstractStatementSupport<Revision, RevisionDateStatement,
+ EffectiveStatement<Revision, RevisionDateStatement>> {
public Definition() {
super(YangStmtMapping.REVISION_DATE);
}
@Override
- public Date parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
+ public Revision parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
try {
- return SimpleDateFormatUtil.getRevisionFormat().parse(value);
- } catch (ParseException e) {
+ return Revision.valueOf(value);
+ } catch (IllegalArgumentException e) {
throw new SourceException(ctx.getStatementSourceReference(), e,
"Revision value %s is not in required format yyyy-MM-dd", value);
}
}
@Override
- public RevisionDateStatement createDeclared(final StmtContext<Date, RevisionDateStatement, ?> ctx) {
+ public RevisionDateStatement createDeclared(final StmtContext<Revision, RevisionDateStatement, ?> ctx) {
return new RevisionDateStatementImpl(ctx);
}
@Override
- public EffectiveStatement<Date, RevisionDateStatement> createEffective(
- final StmtContext<Date, RevisionDateStatement, EffectiveStatement<Date, RevisionDateStatement>> ctx) {
+ public EffectiveStatement<Revision, RevisionDateStatement> createEffective(final StmtContext<Revision,
+ RevisionDateStatement, EffectiveStatement<Revision, RevisionDateStatement>> ctx) {
return new RevisionDateEffectiveStatementImpl(ctx);
}
}
@Override
- public Date getDate() {
+ public Revision getDate() {
return argument();
}
}
*/
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
-import java.text.ParseException;
-import java.util.Date;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
-import org.opendaylight.yangtools.yang.common.SimpleDateFormatUtil;
+import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.DescriptionStatement;
import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.RevisionEffectiveStatementImpl;
-public class RevisionStatementImpl extends AbstractDeclaredStatement<Date>
+public class RevisionStatementImpl extends AbstractDeclaredStatement<Revision>
implements RevisionStatement {
private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(
YangStmtMapping.REVISION)
.addOptional(YangStmtMapping.REFERENCE)
.build();
- protected RevisionStatementImpl(final StmtContext<Date, RevisionStatement, ?> context) {
+ protected RevisionStatementImpl(final StmtContext<Revision, RevisionStatement, ?> context) {
super(context);
}
- public static class Definition
- extends
- AbstractStatementSupport<Date, RevisionStatement, EffectiveStatement<Date, RevisionStatement>> {
+ public static class Definition extends
+ AbstractStatementSupport<Revision, RevisionStatement, EffectiveStatement<Revision, RevisionStatement>> {
public Definition() {
super(YangStmtMapping.REVISION);
}
@Override
- public Date parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
+ public Revision parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
try {
- return SimpleDateFormatUtil.getRevisionFormat().parse(value);
- } catch (ParseException e) {
+ return Revision.valueOf(value);
+ } catch (IllegalArgumentException e) {
throw new SourceException(ctx.getStatementSourceReference(), e,
"Revision value %s is not in required format yyyy-MM-dd", value);
}
}
@Override
- public RevisionStatement createDeclared(final StmtContext<Date, RevisionStatement, ?> ctx) {
+ public RevisionStatement createDeclared(final StmtContext<Revision, RevisionStatement, ?> ctx) {
return new RevisionStatementImpl(ctx);
}
@Override
- public EffectiveStatement<Date, RevisionStatement> createEffective(
- final StmtContext<Date, RevisionStatement, EffectiveStatement<Date, RevisionStatement>> ctx) {
+ public EffectiveStatement<Revision, RevisionStatement> createEffective(
+ final StmtContext<Revision, RevisionStatement, EffectiveStatement<Revision, RevisionStatement>> ctx) {
return new RevisionEffectiveStatementImpl(ctx);
}
@Nonnull
@Override
- public Date getDate() {
+ public Revision getDate() {
return argument();
}
import static org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils.findFirstDeclaredSubstatement;
import static org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils.firstAttributeOf;
-import java.util.Date;
import java.util.Optional;
import javax.annotation.Nonnull;
+import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.model.api.ModuleIdentifier;
import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
private static ModuleIdentifier getSubmoduleIdentifier(
final Mutable<String, SubmoduleStatement, EffectiveStatement<String, SubmoduleStatement>> stmt) {
- final Date maybeDate = StmtContextUtils.getLatestRevision(stmt.declaredSubstatements());
-
- final ModuleIdentifier submoduleIdentifier = ModuleIdentifierImpl.create(stmt.getStatementArgument(),
- Optional.ofNullable(maybeDate));
- return submoduleIdentifier;
+ final Optional<Revision> maybeDate = StmtContextUtils.getLatestRevision(stmt.declaredSubstatements());
+ return ModuleIdentifierImpl.create(stmt.getStatementArgument(), maybeDate);
}
@Override
import java.net.URI;
import java.util.ArrayList;
import java.util.Collection;
-import java.util.Date;
import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import javax.annotation.Nonnull;
import org.opendaylight.yangtools.concepts.SemVer;
import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.common.YangVersion;
import org.opendaylight.yangtools.yang.model.api.AugmentationSchema;
import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
}
@Override
- public Optional<Date> getRevision() {
+ public Optional<Revision> getRevision() {
return getQNameModule().getRevision();
}
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableSet;
import java.net.URI;
-import java.util.Date;
import java.util.List;
import java.util.Objects;
import java.util.Optional;
import java.util.Set;
import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.common.QNameModule;
+import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.model.api.ActionDefinition;
import org.opendaylight.yangtools.yang.model.api.AugmentationSchema;
import org.opendaylight.yangtools.yang.model.api.NamespaceRevisionAware;
implements AugmentationSchema, NamespaceRevisionAware {
private final SchemaPath targetPath;
private final URI namespace;
- private final Date revision;
+ private final Revision revision;
private final Set<ActionDefinition> actions;
private final Set<NotificationDefinition> notifications;
private final List<UnknownSchemaNode> unknownNodes;
}
@Override
- public Date getRevision() {
- return revision;
+ public Optional<Revision> getRevision() {
+ return Optional.ofNullable(revision);
}
@Override
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective;
import com.google.common.base.MoreObjects;
-import java.util.Date;
import java.util.Objects;
import java.util.Optional;
import org.opendaylight.yangtools.concepts.SemVer;
-import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
+import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.model.api.ModuleImport;
import org.opendaylight.yangtools.yang.model.api.stmt.ImportStatement;
import org.opendaylight.yangtools.yang.model.repo.api.SemVerSourceIdentifier;
implements ModuleImport {
private final String moduleName;
- private final Date revision;
+ private final Revision revision;
private final SemVer semVer;
private final String prefix;
private final String description;
} else {
final SemVerSourceIdentifier importedModuleIdentifier = ctx.getFromNamespace(
ImportPrefixToSemVerSourceIdentifier.class, prefix);
- revision = QName.parseRevision(importedModuleIdentifier.getRevision());
+ revision = Revision.valueOf(importedModuleIdentifier.getRevision());
semVer = importedModuleIdentifier.getSemanticVersion().orElse(null);
}
this.reference = referenceStmt != null ? referenceStmt.argument() : null;
}
- private Date getImportedRevision(final StmtContext<String, ImportStatement, ?> ctx) {
+ private Revision getImportedRevision(final StmtContext<String, ImportStatement, ?> ctx) {
/*
* When 'revision-date' of an import is not specified in yang source, we
* need to find revision of imported module.
}
@Override
- public Optional<Date> getRevision() {
+ public Optional<Revision> getRevision() {
return Optional.ofNullable(revision);
}
*/
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective;
-import java.util.Date;
+import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.model.api.stmt.RevisionDateStatement;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
public final class RevisionDateEffectiveStatementImpl
- extends DeclaredEffectiveStatementBase<Date, RevisionDateStatement> {
- public RevisionDateEffectiveStatementImpl(final StmtContext<Date, RevisionDateStatement, ?> ctx) {
+ extends DeclaredEffectiveStatementBase<Revision, RevisionDateStatement> {
+ public RevisionDateEffectiveStatementImpl(final StmtContext<Revision, RevisionDateStatement, ?> ctx) {
super(ctx);
}
}
*/
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective;
-import java.util.Date;
+import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.model.api.DocumentedNode;
import org.opendaylight.yangtools.yang.model.api.stmt.RevisionStatement;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
-public final class RevisionEffectiveStatementImpl extends DeclaredEffectiveStatementBase<Date, RevisionStatement>
+public final class RevisionEffectiveStatementImpl extends DeclaredEffectiveStatementBase<Revision, RevisionStatement>
implements DocumentedNode {
private final String reference;
private final String description;
- public RevisionEffectiveStatementImpl(final StmtContext<Date, RevisionStatement, ?> ctx) {
+ public RevisionEffectiveStatementImpl(final StmtContext<Revision, RevisionStatement, ?> ctx) {
super(ctx);
final DescriptionEffectiveStatementImpl descStmt = firstEffective(DescriptionEffectiveStatementImpl.class);
import java.text.ParseException;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.data.util.ConstraintDefinitions;
import org.opendaylight.yangtools.yang.model.api.ConstraintDefinition;
import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode;
final SchemaContext schemaContext = reactor.buildEffective();
assertNotNull(schemaContext);
- final Module testModule = schemaContext.findModule("foo", QName.parseRevision("2016-09-20")).get();
+ final Module testModule = schemaContext.findModule("foo", Revision.valueOf("2016-09-20")).get();
final LeafSchemaNode mandatoryLeaf1 = (LeafSchemaNode) testModule.getDataChildByName(
QName.create(testModule.getQNameModule(), "mandatory-leaf-1"));
assertNotNull(mandatoryLeaf1);
import java.util.Set;
import org.junit.Test;
-import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.MustDefinition;
final SchemaContext schemaContext = StmtTestUtils.parseYangSource("/rfc7950/bug6871/foo.yang");
assertNotNull(schemaContext);
- final Module foo = schemaContext.findModule("foo", QName.parseRevision("2016-12-14")).get();
+ final Module foo = schemaContext.findModule("foo", Revision.valueOf("2016-12-14")).get();
final Set<NotificationDefinition> notifications = foo.getNotifications();
assertEquals(1, notifications.size());
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
+import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
final SchemaContext schemaContext = StmtTestUtils.parseYangSource("/rfc7950/bug6887/foo.yang");
assertNotNull(schemaContext);
- final Module foo = schemaContext.findModule("foo", QName.parseRevision("2017-01-26")).get();
+ final Module foo = schemaContext.findModule("foo", Revision.valueOf("2017-01-26")).get();
final LeafSchemaNode myEnumerationLeaf = (LeafSchemaNode) foo.getDataChildByName(
QName.create(foo.getQNameModule(), "my-enumeration-leaf"));
assertNotNull(myEnumerationLeaf);
final SchemaContext schemaContext = StmtTestUtils.parseYangSource("/rfc7950/bug6887/bar.yang");
assertNotNull(schemaContext);
- final Module bar = schemaContext.findModule("bar", QName.parseRevision("2017-02-02")).get();
+ final Module bar = schemaContext.findModule("bar", Revision.valueOf("2017-02-02")).get();
final LeafSchemaNode myBitsLeaf = (LeafSchemaNode) bar.getDataChildByName(
QName.create(bar.getQNameModule(), "my-bits-leaf"));
assertNotNull(myBitsLeaf);
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.model.api.ActionDefinition;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
import org.opendaylight.yangtools.yang.model.api.Module;
final SchemaContext schemaContext = StmtTestUtils.parseYangSource("/rfc7950/bug9241/foo.yang");
assertNotNull(schemaContext);
- final Module fooModule = schemaContext.findModule("foo", QName.parseRevision("2017-10-13")).get();
+ final Module fooModule = schemaContext.findModule("foo", Revision.valueOf("2017-10-13")).get();
final ContainerSchemaNode actionCont = (ContainerSchemaNode) fooModule.getDataChildByName(QName.create(
fooModule.getQNameModule(), "action-cont"));
import java.util.Set;
import org.junit.Test;
-import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.model.api.IdentitySchemaNode;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
final SchemaContext schemaContext = StmtTestUtils.parseYangSource("/rfc7950/identity-stmt/foo.yang");
assertNotNull(schemaContext);
- final Module foo = schemaContext.findModule("foo", QName.parseRevision("2016-12-21")).get();
+ final Module foo = schemaContext.findModule("foo", Revision.valueOf("2016-12-21")).get();
final Set<IdentitySchemaNode> identities = foo.getIdentities();
for (final IdentitySchemaNode identity : identities) {
if ("derived-id".equals(identity.getQName().getLocalName())) {
import java.util.Set;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.model.api.IdentitySchemaNode;
import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
import org.opendaylight.yangtools.yang.model.api.Module;
final SchemaContext schemaContext = StmtTestUtils.parseYangSource("/rfc7950/identityref-stmt/foo.yang");
assertNotNull(schemaContext);
- final Module foo = schemaContext.findModule("foo", QName.parseRevision("2017-01-11")).get();
+ final Module foo = schemaContext.findModule("foo", Revision.valueOf("2017-01-11")).get();
final Set<IdentitySchemaNode> identities = foo.getIdentities();
assertEquals(3, identities.size());
import java.util.Set;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
final SchemaContext schemaContext = StmtTestUtils.parseYangSource("/rfc7950/leafref-stmt/foo.yang");
assertNotNull(schemaContext);
- final Module foo = schemaContext.findModule("foo", QName.parseRevision("2016-12-20")).get();
+ final Module foo = schemaContext.findModule("foo", Revision.valueOf("2016-12-20")).get();
final Set<TypeDefinition<?>> typeDefinitions = foo.getTypeDefinitions();
assertEquals(1, typeDefinitions.size());
import java.io.IOException;
import java.net.URI;
import java.net.URISyntaxException;
-import java.text.ParseException;
import java.util.Collections;
import java.util.Optional;
import org.junit.Test;
import org.mockito.MockitoAnnotations;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
+import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.model.api.ChoiceSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
@Test
public void findNodeInSchemaContextTest() throws URISyntaxException, IOException, YangSyntaxErrorException,
- ParseException, ReactorException {
+ ReactorException {
final SchemaContext context = TestUtils.parseYangSources("/schema-context-util-test");
- final Module myModule = context.findModule(new URI("uri:my-module"), QName.parseRevision("2014-10-07")).get();
+ final Module myModule = context.findModule(new URI("uri:my-module"),Revision.valueOf("2014-10-07")).get();
SchemaNode testNode = ((ContainerSchemaNode) myModule.getDataChildByName(QName.create(
myModule.getQNameModule(), "my-container"))).getDataChildByName(QName.create(myModule.getQNameModule(),
@Test
public void findNodeInSchemaContextTest2() throws URISyntaxException, IOException, YangSyntaxErrorException,
- ParseException, ReactorException {
+ ReactorException {
final SchemaContext context = TestUtils.parseYangSources("/schema-context-util-test");
- final Module myModule = context.findModule(new URI("uri:my-module"), QName.parseRevision("2014-10-07")).get();
+ final Module myModule = context.findModule(new URI("uri:my-module"), Revision.valueOf("2014-10-07")).get();
SchemaNode testNode = ((ContainerSchemaNode) myModule.getDataChildByName(QName.create(
myModule.getQNameModule(), "my-container"))).getDataChildByName(QName.create(myModule.getQNameModule(),
@Test
public void findNodeInSchemaContextTest3() throws URISyntaxException, IOException, YangSyntaxErrorException,
- ParseException, ReactorException {
+ ReactorException {
final SchemaContext context = TestUtils.parseYangSources("/schema-context-util-test");
- final Module myModule = context.findModule(new URI("uri:my-module"), QName.parseRevision("2014-10-07")).get();
+ final Module myModule = context.findModule(new URI("uri:my-module"), Revision.valueOf("2014-10-07")).get();
SchemaNode testNode = myModule.getDataChildByName(QName.create(myModule.getQNameModule(), "my-container"));
@Test
public void findParentModuleTest() throws URISyntaxException, IOException, YangSyntaxErrorException,
- ParseException, ReactorException {
+ ReactorException {
final SchemaContext context = TestUtils.parseYangSources("/schema-context-util-test");
- final Module myModule = context.findModule(new URI("uri:my-module"), QName.parseRevision("2014-10-07")).get();
+ final Module myModule = context.findModule(new URI("uri:my-module"), Revision.valueOf("2014-10-07")).get();
- final DataSchemaNode node = myModule
- .getDataChildByName(QName.create(myModule.getQNameModule(), "my-container"));
+ final DataSchemaNode node = myModule.getDataChildByName(QName.create(myModule.getQNameModule(),
+ "my-container"));
final Module foundModule = SchemaContextUtil.findParentModule(context, node);
public void findDataSchemaNodeTest() throws URISyntaxException, IOException, YangSyntaxErrorException,
ReactorException {
final SchemaContext context = TestUtils.parseYangSources("/schema-context-util-test");
- final Module module = context.findModule(new URI("uri:my-module"), QName.parseRevision("2014-10-07")).get();
+ final Module module = context.findModule(new URI("uri:my-module"), Revision.valueOf("2014-10-07")).get();
final Module importedModule = context.findModule(new URI("uri:imported-module"),
- QName.parseRevision("2014-10-07")).get();
+ Revision.valueOf("2014-10-07")).get();
final SchemaNode testNode = ((ContainerSchemaNode) importedModule.getDataChildByName(QName.create(
importedModule.getQNameModule(), "my-imported-container"))).getDataChildByName(QName.create(
// final RevisionAwareXPath nonCondXPath) {
final SchemaContext context = TestUtils.parseYangSources("/schema-context-util-test");
- final Module module = context.findModule(new URI("uri:my-module"), QName.parseRevision("2014-10-07")).get();
+ final Module module = context.findModule(new URI("uri:my-module"), Revision.valueOf("2014-10-07")).get();
final GroupingDefinition grouping = getGroupingByName(module, "my-grouping");
final SchemaNode testNode = grouping.getDataChildByName(QName.create(module.getQNameModule(),
@Test
public void findNodeInSchemaContextGroupingsTest() throws URISyntaxException, IOException,
- YangSyntaxErrorException, ParseException, ReactorException {
+ YangSyntaxErrorException, ReactorException {
final SchemaContext context = TestUtils.parseYangSources("/schema-context-util-test");
- final Module myModule = context.findModule(new URI("uri:my-module"), QName.parseRevision("2014-10-07")).get();
+ final Module myModule = context.findModule(URI.create("uri:my-module"), Revision.valueOf("2014-10-07")).get();
// find grouping in container
DataNodeContainer dataContainer = (DataNodeContainer) myModule.getDataChildByName(QName.create(
@Test
public void findNodeInSchemaContextGroupingsTest2() throws URISyntaxException, IOException,
- YangSyntaxErrorException, ParseException, ReactorException {
+ YangSyntaxErrorException, ReactorException {
final SchemaContext context = TestUtils.parseYangSources("/schema-context-util-test");
- final Module myModule = context.findModule(new URI("uri:my-module"), QName.parseRevision("2014-10-07")).get();
+ final Module myModule = context.findModule(new URI("uri:my-module"), Revision.valueOf("2014-10-07")).get();
// find grouping in container
DataNodeContainer dataContainer = (DataNodeContainer) myModule.getDataChildByName(QName.create(
@Test
public void findNodeInSchemaContextTheSameNameOfSiblingsTest() throws URISyntaxException, IOException,
- YangSyntaxErrorException, ParseException, ReactorException {
+ YangSyntaxErrorException, ReactorException {
final SchemaContext context = TestUtils.parseYangSources("/schema-context-util-test");
- final Module myModule = context.findModule(new URI("uri:my-module"), QName.parseRevision("2014-10-07")).get();
+ final Module myModule = context.findModule(new URI("uri:my-module"), Revision.valueOf("2014-10-07")).get();
final ChoiceSchemaNode choice = (ChoiceSchemaNode) getRpcByName(myModule, "my-name").getInput()
.getDataChildByName(QName.create(myModule.getQNameModule(), "my-choice"));
final SchemaNode testNode = choice.getCaseNodeByName("case-two").getDataChildByName(
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
-import java.util.Date;
import java.util.List;
import java.util.Set;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
+import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.common.YangConstants;
import org.opendaylight.yangtools.yang.model.api.AugmentationSchema;
import org.opendaylight.yangtools.yang.model.api.ChoiceCaseNode;
public class AugmentTest {
private static final QNameModule FOO = QNameModule.create(
- URI.create("urn:opendaylight.foo"), QName.parseRevision("2013-10-13"));
+ URI.create("urn:opendaylight.foo"), Revision.valueOf("2013-10-13"));
private static final QNameModule BAR = QNameModule.create(
- URI.create("urn:opendaylight.bar"), QName.parseRevision("2013-10-14"));
+ URI.create("urn:opendaylight.bar"), Revision.valueOf("2013-10-14"));
private static final QNameModule BAZ = QNameModule.create(
- URI.create("urn:opendaylight.baz"), QName.parseRevision("2013-10-15"));
+ URI.create("urn:opendaylight.baz"), Revision.valueOf("2013-10-15"));
private static final QName Q0 = QName.create(BAR, "interfaces");
private static final QName Q1 = QName.create(BAR, "ifEntry");
final SchemaContext context = TestUtils.loadModules(getClass().getResource("/augment-test/rpc").toURI());
final URI NS_BAR = URI.create("urn:opendaylight:bar");
final URI NS_FOO = URI.create("urn:opendaylight:foo");
- final Date revision = QName.parseRevision("2013-10-11");
-
+ final Revision revision = Revision.valueOf("2013-10-11");
final Module bar = TestUtils.findModule(context, "bar").get();
final Set<RpcDefinition> rpcs = bar.getRpcs();
assertEquals(2, rpcs.size());
import static org.junit.Assert.assertNotNull;
import java.net.URI;
-import java.util.Date;
import java.util.List;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
+import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
assertEquals(1, unknownNodes.size());
final UnknownSchemaNode action = unknownNodes.get(0);
- final Date revision = QName.parseRevision("2014-07-25");
- final QNameModule qm = QNameModule.create(URI.create("urn:test:bug1412"), revision);
+ final QNameModule qm = QNameModule.create(URI.create("urn:test:bug1412"), Revision.valueOf("2014-07-25"));
QName expectedNodeType = QName.create("urn:test:bug1412:ext:definitions", "2014-07-25", "action");
assertEquals(expectedNodeType, action.getNodeType());
assertEquals("hello", action.getNodeParameter());
import java.net.URI;
import java.util.ArrayList;
-import java.util.Date;
import java.util.List;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
+import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
final SchemaContext schema = StmtTestUtils.parseYangSources("/bugs/bug2872");
assertNotNull(schema);
- final Date revision = QName.parseRevision("2016-06-08");
- final QNameModule bug2872module = QNameModule.create(new URI("bug2872"), revision);
+ final QNameModule bug2872module = QNameModule.create(URI.create("bug2872"), Revision.valueOf("2016-06-08"));
final QName foo = QName.create(bug2872module, "bar");
final DataSchemaNode dataSchemaNode = schema.getDataChildByName(foo);
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
+import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.model.api.SchemaNode;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
assertNotNull(context);
- QNameModule foo = QNameModule.create(new URI("foo"), QName.parseRevision("2015-09-02"));
+ QNameModule foo = QNameModule.create(new URI("foo"), Revision.valueOf("2015-09-02"));
SchemaPath targetPath = SchemaPath
.create(true, QName.create(foo, "augment-target"))
import static org.junit.Assert.assertTrue;
import java.net.URI;
-import java.util.Date;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
+import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.model.api.SchemaNode;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
public void test() throws Exception {
SchemaContext context = StmtTestUtils.parseYangSources("/bugs/bug4610");
- Date revision = QName.parseRevision("2015-12-12");
- QNameModule foo = QNameModule.create(new URI("foo"), revision);
- QNameModule bar = QNameModule.create(new URI("bar"), revision);
+ Revision revision = Revision.valueOf("2015-12-12");
+ QNameModule foo = QNameModule.create(URI.create("foo"), revision);
+ QNameModule bar = QNameModule.create(URI.create("bar"), revision);
QName g1 = QName.create(bar, "g1");
QName g2 = QName.create(bar, "g2");
import java.util.Set;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.model.api.AugmentationSchema;
import org.opendaylight.yangtools.yang.model.api.ChoiceCaseNode;
import org.opendaylight.yangtools.yang.model.api.ChoiceSchemaNode;
final QName root = QName.create(NS, REV, "main-container");
final QName choice = QName.create(NS, REV, "test-choice");
final QName testContainerQname = QName.create(NS, REV, "test");
- final Module foo = context.findModule("foo", QName.parseRevision("2016-01-01")).get();
+ final Module foo = context.findModule("foo", Revision.valueOf("2016-01-01")).get();
final ContainerSchemaNode rootContainer = (ContainerSchemaNode) context.getDataChildByName(root);
final ContainerSchemaNode testContainer = (ContainerSchemaNode) rootContainer.getDataChildByName(
testContainerQname);
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
-import static org.opendaylight.yangtools.yang.common.SimpleDateFormatUtil.getRevisionFormat;
import java.text.ParseException;
-import java.util.Date;
import java.util.Optional;
import java.util.Set;
import org.junit.Before;
import org.junit.Test;
+import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.ModuleImport;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
public class Bug6491Test {
- private Date date;
+ private Revision date;
@Before
public void setup() throws ParseException {
- date = getRevisionFormat().parse("2016-01-01");
+ date = Revision.valueOf("2016-01-01");
}
@Test
testRevision("moduleRevisionOnly", date, Optional.empty());
}
- private static void testRevision(final String path, final Date moduleRevision,
- final Optional<Date> importedRevision) throws Exception {
+ private static void testRevision(final String path, final Revision moduleRevision,
+ final Optional<Revision> importedRevision) throws Exception {
final SchemaContext context = StmtTestUtils.parseYangSources("/bugs/bug6491/".concat(path));
assertNotNull(context);
final Module module = context.findModule("bar", moduleRevision).get();
import static org.junit.Assert.assertTrue;
import com.google.common.collect.ImmutableSet;
-import java.util.Date;
import java.util.Optional;
import java.util.Set;
import org.junit.Test;
-import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.model.api.ModuleIdentifier;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.model.util.ModuleIdentifierImpl;
@Test
public void testBug6961SchemaContext() throws Exception {
- final Optional<Date> date = Optional.of(QName.parseRevision("2016-01-01"));
- final ModuleIdentifier foo = ModuleIdentifierImpl.create("foo", date);
- final ModuleIdentifier sub1Foo = ModuleIdentifierImpl.create("sub1-foo", date);
- final ModuleIdentifier sub2Foo = ModuleIdentifierImpl.create("sub2-foo", date);
- final ModuleIdentifier bar = ModuleIdentifierImpl.create("bar", date);
- final ModuleIdentifier sub1Bar = ModuleIdentifierImpl.create("sub1-bar", date);
- final ModuleIdentifier baz = ModuleIdentifierImpl.create("baz", date);
+ final Optional<Revision> revision = Optional.of(Revision.valueOf("2016-01-01"));
+ final ModuleIdentifier foo = ModuleIdentifierImpl.create("foo", revision);
+ final ModuleIdentifier sub1Foo = ModuleIdentifierImpl.create("sub1-foo", revision);
+ final ModuleIdentifier sub2Foo = ModuleIdentifierImpl.create("sub2-foo", revision);
+ final ModuleIdentifier bar = ModuleIdentifierImpl.create("bar", revision);
+ final ModuleIdentifier sub1Bar = ModuleIdentifierImpl.create("sub1-bar", revision);
+ final ModuleIdentifier baz = ModuleIdentifierImpl.create("baz", revision);
final Set<ModuleIdentifier> testSet = ImmutableSet.of(foo, sub1Foo, sub2Foo, bar, sub1Bar, baz);
final SchemaContext context = StmtTestUtils.parseYangSources("/bugs/bug6961/");
assertNotNull(context);
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
-import java.util.Date;
import org.junit.Ignore;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
import org.opendaylight.yangtools.yang.model.api.Module;
assertNotNull(schemaContext);
assertEquals(3, schemaContext.getModules().size());
- final Date revision = QName.parseRevision("2016-10-20");
+ final Revision revision = Revision.valueOf("2016-10-20");
final Module foo = schemaContext.findModule("foo", revision).get();
final Module bar = schemaContext.findModule("bar", revision).get();
final Module baz = schemaContext.findModule("baz", revision).get();
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
-import java.util.Date;
import java.util.List;
import java.util.Set;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.model.api.DeviateDefinition;
import org.opendaylight.yangtools.yang.model.api.Deviation;
import org.opendaylight.yangtools.yang.model.api.Module;
final SchemaContext schemaContext = StmtTestUtils.parseYangSources("/bugs/bug7440");
assertNotNull(schemaContext);
- final Date revision = QName.parseRevision("2016-12-23");
+ final Revision revision = Revision.valueOf("2016-12-23");
final Module foo = schemaContext.findModule("foo", revision).get();
final Module bar = schemaContext.findModule("bar", revision).get();
import java.net.URI;
import java.util.Set;
import org.junit.Test;
-import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.SomeModifiersUnresolvedException;
final Set<Module> modules = context.getModules();
assertEquals(8, modules.size());
- assertNotNull(context.findModule(new URI("foo-imp"), QName.parseRevision("2017-01-23")));
+ assertNotNull(context.findModule(new URI("foo-imp"), Revision.valueOf("2017-01-23")));
assertEquals(1, context.findModules(new URI("foo-imp-2")).size());
assertEquals(1, context.findModules(new URI("foo-imp-imp")).size());
assertEquals(1, context.findModules(new URI("bar")).size());
assertEquals(1, context.findModules(new URI("baz")).size());
- assertTrue(context.findModule(new URI("baz-imp"), QName.parseRevision("2002-01-01")).isPresent());
+ assertTrue(context.findModule(new URI("baz-imp"), Revision.valueOf("2002-01-01")).isPresent());
final Set<Module> foo = context.findModules(new URI("foo"));
assertEquals(1, foo.size());
final Set<Module> subFoos = foo.iterator().next().getSubmodules();
assertEquals(1, subFoos.size());
- final Module parentMod = context.findModule(new URI("parent-mod-ns"), QName.parseRevision("2017-09-07")).get();
+ final Module parentMod = context.findModule(new URI("parent-mod-ns"), Revision.valueOf("2017-09-07")).get();
assertEquals(1, parentMod.getSubmodules().size());
}
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableSet;
import java.net.URI;
-import java.text.ParseException;
-import java.util.Date;
import java.util.Map;
import java.util.Set;
import org.junit.BeforeClass;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
-import org.opendaylight.yangtools.yang.common.SimpleDateFormatUtil;
+import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.util.SchemaContextUtil;
private static final URI BAR_NS = URI.create("bar-ns");
private static final URI BAZ_NS = URI.create("baz-ns");
- private static Date revision;
+ private static Revision revision;
private static QNameModule foo;
private static QName myFooContA;
private static QName myFooContB;
private static QName myBazCont;
@BeforeClass
- public static void setup() throws ParseException {
- revision = SimpleDateFormatUtil.getRevisionFormat().parse("2017-05-16");
+ public static void setup() {
+ revision = Revision.valueOf("2017-05-16");
foo = QNameModule.create(FOO_NS, revision);
myFooContA = QName.create(foo, "my-foo-cont-a");
myFooContB = QName.create(foo, "my-foo-cont-b");
import java.util.Optional;
import java.util.Set;
import org.junit.Test;
-import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.ModuleImport;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
for (final ModuleImport moduleImport : imports) {
switch (moduleImport.getModuleName()) {
case "bar":
- assertEquals(Optional.of(QName.parseRevision("1970-01-01")), moduleImport.getRevision());
+ assertEquals(Optional.of(Revision.valueOf("1970-01-01")), moduleImport.getRevision());
assertEquals("bar-ref", moduleImport.getReference());
assertEquals("bar-desc", moduleImport.getDescription());
break;
case "baz":
- assertEquals(Optional.of(QName.parseRevision("2010-10-10")), moduleImport.getRevision());
+ assertEquals(Optional.of(Revision.valueOf("2010-10-10")), moduleImport.getRevision());
assertEquals("baz-ref", moduleImport.getReference());
assertEquals("baz-desc", moduleImport.getDescription());
break;
import java.util.Optional;
import java.util.Set;
import org.junit.Test;
-import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.ModuleImport;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
final SchemaContext context = StmtTestUtils.parseYangSources("/bugs/bug9005");
assertNotNull(context);
- final Module foo = context.findModule("foo", QName.parseRevision("2017-07-07")).get();
+ final Module foo = context.findModule("foo", Revision.valueOf("2017-07-07")).get();
final Set<ModuleImport> imports = foo.getImports();
assertEquals(1, imports.size());
final ModuleImport imp1 = imports.iterator().next();
assertEquals("bar-2", imp1.getModuleName());
assertEquals("bar", imp1.getPrefix());
- assertEquals(Optional.of(QName.parseRevision("2000-01-02")), imp1.getRevision());
+ assertEquals(Optional.of(Revision.valueOf("2000-01-02")), imp1.getRevision());
final Set<Module> submodules = foo.getSubmodules();
assertEquals(1, submodules.size());
final ModuleImport subImp1 = subImports.iterator().next();
assertEquals("bar-1", subImp1.getModuleName());
assertEquals("bar", subImp1.getPrefix());
- assertEquals(Optional.of(QName.parseRevision("2000-01-01")), subImp1.getRevision());
+ assertEquals(Optional.of(Revision.valueOf("2000-01-01")), subImp1.getRevision());
}
}
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertSame;
-import java.util.Date;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.model.api.Deviation;
import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
import org.opendaylight.yangtools.yang.model.api.Module;
final SchemaContext schemaContext = StmtTestUtils.parseYangSources("/bugs/bug9242/");
assertNotNull(schemaContext);
- final Date revision = QName.parseRevision("2017-10-13");
-
+ final Revision revision = Revision.valueOf("2017-10-13");
final Module rootModule = schemaContext.findModule("root-module", revision).get();
final Module impModule = schemaContext.findModule("imp-module", revision).get();
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode;
import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
final SchemaContext schemaContext = StmtTestUtils.parseYangSources("/bugs/bug9244/");
assertNotNull(schemaContext);
- final Module barModule = schemaContext.findModule("bar", QName.parseRevision("2017-10-13")).get();
+ final Module barModule = schemaContext.findModule("bar", Revision.valueOf("2017-10-13")).get();
final ContainerSchemaNode barCont = (ContainerSchemaNode) barModule.getDataChildByName(
QName.create(barModule.getQNameModule(), "bar-cont"));
assertNotNull(barCont);
import static org.junit.Assert.assertTrue;
import java.net.URI;
-import java.text.SimpleDateFormat;
-import java.util.Date;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
-import org.opendaylight.yangtools.yang.common.SimpleDateFormatUtil;
+import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.model.api.ChoiceCaseNode;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
import org.opendaylight.yangtools.yang.model.api.Module;
@Before
public void setup() throws Exception {
schema = StmtTestUtils.parseYangSources("/case-test");
- String date_s = "2015-09-09 00:00:00.0";
- SimpleDateFormat dt = SimpleDateFormatUtil.getRevisionFormat();
- Date date = dt.parse(date_s);
- rootFoo = schema.findModule("foo", date).get();
- rootBar = schema.findModule("bar", date).get();
+ Revision rev = Revision.valueOf("2015-09-09");
+ rootFoo = schema.findModule("foo", rev).get();
+ rootBar = schema.findModule("bar", rev).get();
assertNotNull(rootFoo);
assertNotNull(rootBar);
- qnameFoo = QNameModule.create(URI.create("foo"), date);
- qnameBar = QNameModule.create(URI.create("bar"), date);
+ qnameFoo = QNameModule.create(URI.create("foo"), rev);
+ qnameBar = QNameModule.create(URI.create("bar"), rev);
assertNotNull(qnameFoo);
assertNotNull(qnameBar);
}
import static org.junit.Assert.assertTrue;
import java.net.URI;
-import java.net.URISyntaxException;
-import java.text.ParseException;
import java.util.List;
import java.util.Set;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
+import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.model.api.AugmentationSchema;
import org.opendaylight.yangtools.yang.model.api.ChoiceCaseNode;
import org.opendaylight.yangtools.yang.model.api.ChoiceSchemaNode;
configModuleTest(context);
}
- private static void salDomBrokerImplModuleTest(final SchemaContext context)
- throws ParseException {
+ private static void salDomBrokerImplModuleTest(final SchemaContext context) {
final Module module = context.findModule("opendaylight-sal-dom-broker-impl",
- QName.parseRevision("2013-10-28")).get();
+ Revision.valueOf("2013-10-28")).get();
final Set<AugmentationSchema> augmentations = module.getAugmentations();
boolean checked = false;
assertTrue(checked);
}
- private static void configModuleTest(final SchemaContext context) throws ParseException,
- URISyntaxException {
- final Module configModule = context.findModule("config", QName.parseRevision("2013-04-05")).get();
+ private static void configModuleTest(final SchemaContext context) {
+ final Module configModule = context.findModule("config", Revision.valueOf("2013-04-05")).get();
final Module module = context.findModule("opendaylight-sal-dom-broker-impl",
- QName.parseRevision("2013-10-28")).get();
+ Revision.valueOf("2013-10-28")).get();
final DataSchemaNode dataNode = configModule.getDataChildByName(QName.create(configModule.getQNameModule(),
"modules"));
assertEquals(1, typeUnknownSchemaNodes.size());
final UnknownSchemaNode typeUnknownSchemaNode = typeUnknownSchemaNodes.get(0);
- final QNameModule qNameModule = QNameModule
- .create(new URI("urn:opendaylight:params:xml:ns:yang:controller:md:sal:dom"),
- QName.parseRevision("2013-10-28"));
+ final QNameModule qNameModule = QNameModule.create(
+ URI.create("urn:opendaylight:params:xml:ns:yang:controller:md:sal:dom"), Revision.valueOf("2013-10-28"));
final QName qName = QName.create(qNameModule, "schema-service");
assertEquals(qName, typeUnknownSchemaNode.getQName());
import java.text.ParseException;
import java.util.Collection;
-import java.util.Date;
import java.util.Set;
import java.util.function.Predicate;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.model.api.AnyXmlSchemaNode;
import org.opendaylight.yangtools.yang.model.api.AugmentationSchema;
import org.opendaylight.yangtools.yang.model.api.ChoiceSchemaNode;
final SchemaContext schemaContext = StmtTestUtils.parseYangSources(rootModule, importedModule);
assertNotNull(schemaContext);
- final Date revision = QName.parseRevision("2016-09-28");
-
+ final Revision revision = Revision.valueOf("2016-09-28");
final Module testModule = schemaContext.findModule("root-module-declared-test", revision).get();
assertNotNull(testModule);
import java.io.PrintStream;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.model.api.AnyXmlSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ChoiceSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
"/deviation-resolution-test/deviation-not-supported");
assertNotNull(schemaContext);
- final Module importedModule = schemaContext.findModule("imported", QName.parseRevision("2017-01-20")).get();
+ final Module importedModule = schemaContext.findModule("imported", Revision.valueOf("2017-01-20")).get();
final ContainerSchemaNode myContA = (ContainerSchemaNode) importedModule.getDataChildByName(
QName.create(importedModule.getQNameModule(), "my-cont-a"));
assertNotNull(myContA);
sourceForResource("/deviation-resolution-test/deviation-add/bar.yang"));
assertNotNull(schemaContext);
- final Module barModule = schemaContext.findModule("bar", QName.parseRevision("2017-01-20")).get();
+ final Module barModule = schemaContext.findModule("bar", Revision.valueOf("2017-01-20")).get();
final LeafListSchemaNode myLeafList = (LeafListSchemaNode) barModule.getDataChildByName(
QName.create(barModule.getQNameModule(), "my-leaf-list"));
assertNotNull(myLeafList);
sourceForResource("/deviation-resolution-test/deviation-replace/bar.yang"));
assertNotNull(schemaContext);
- final Module barModule = schemaContext.findModule("bar", QName.parseRevision("2017-01-20")).get();
+ final Module barModule = schemaContext.findModule("bar", Revision.valueOf("2017-01-20")).get();
assertNotNull(barModule);
final LeafSchemaNode myLeaf = (LeafSchemaNode) barModule.getDataChildByName(
sourceForResource("/deviation-resolution-test/deviation-delete/bar.yang"));
assertNotNull(schemaContext);
- final Module barModule = schemaContext.findModule("bar", QName.parseRevision("2017-01-20")).get();
+ final Module barModule = schemaContext.findModule("bar", Revision.valueOf("2017-01-20")).get();
final LeafSchemaNode myLeaf = (LeafSchemaNode) barModule.getDataChildByName(
QName.create(barModule.getQNameModule(), "my-leaf"));
assertNotNull(myLeaf);
import java.util.List;
import java.util.Set;
import org.junit.Test;
-import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.model.api.DeviateDefinition;
import org.opendaylight.yangtools.yang.model.api.DeviateKind;
import org.opendaylight.yangtools.yang.model.api.Deviation;
final SchemaContext schemaContext = reactor.buildEffective();
assertNotNull(schemaContext);
- Module testModule = schemaContext.findModule("foo", QName.parseRevision("2016-06-23")).get();
+ Module testModule = schemaContext.findModule("foo", Revision.valueOf("2016-06-23")).get();
Set<Deviation> deviations = testModule.getDeviations();
assertEquals(4, deviations.size());
}
}
- testModule = schemaContext.findModule("bar", QName.parseRevision("2016-09-22")).get();
+ testModule = schemaContext.findModule("bar", Revision.valueOf("2016-09-22")).get();
assertNotNull(testModule);
deviations = testModule.getDeviations();
import static org.opendaylight.yangtools.yang.stmt.StmtTestUtils.sourceForResource;
import java.net.URI;
-import java.util.Date;
import java.util.List;
import java.util.Optional;
import java.util.Set;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
+import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.common.YangVersion;
import org.opendaylight.yangtools.yang.model.api.AugmentationSchema;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
private static final SchemaPath contSchemaPath = SchemaPath.create(true, cont);
private static final SchemaPath feature1SchemaPath = SchemaPath.create(true, feature1);
- private static final Date REVISION = QName.parseRevision("2000-01-01");
+ private static final Revision REVISION = Revision.valueOf("2000-01-01");
@Test
public void effectiveBuildTest() throws SourceException, ReactorException {
private static void findModulesSubTest(final SchemaContext result, final Module root, final Module imported) {
final Module foundRoot = result.findModule("root-module").get();
final Set<Module> foundRoots = result.findModules(URI.create("root-module"));
- final Module foundRoot3 = result.findModule(URI.create("root-module"), null).get();
+ final Module foundRoot3 = result.findModule(URI.create("root-module")).get();
assertNotNull(foundRoot);
assertNotNull(foundRoots);
final Module foundImported = result.findModule("imported-module").get();
final Set<Module> foundImporteds = result.findModules(URI.create("imported-module"));
- final Module foundImported3 = result.findModule(URI.create("imported-module"), null).get();
+ final Module foundImported3 = result.findModule(URI.create("imported-module")).get();
assertNotNull(foundImported);
assertNotNull(foundImporteds);
import java.util.Set;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ExtensionDefinition;
import org.opendaylight.yangtools.yang.model.api.Module;
assertNull(schemaContext.getDataChildByName(QName.create("foo-namespace", "2016-09-21", "foo-cont")));
- assertFalse(schemaContext.findModule("foo", QName.parseRevision("2016-08-21")).isPresent());
- assertFalse(schemaContext.findModule(URI.create("foo-namespace"), QName.parseRevision("2016-08-21"))
+ assertFalse(schemaContext.findModule("foo", Revision.valueOf("2016-08-21")).isPresent());
+ assertFalse(schemaContext.findModule(URI.create("foo-namespace"), Revision.valueOf("2016-08-21"))
.isPresent());
assertFalse(schemaContext.isAugmenting());
assertNotNull(schemaContext.getAvailableAugmentations());
assertTrue(schemaContext.getAvailableAugmentations().isEmpty());
- Module fooModule = schemaContext.findModule("foo", QName.parseRevision("2016-09-21")).get();
+ Module fooModule = schemaContext.findModule("foo", Revision.valueOf("2016-09-21")).get();
assertEquals(3, schemaContext.getModules().size());
assertEquals(3, ((EffectiveSchemaContext) schemaContext).getRootDeclaredStatements().size());
assertEquals(3,((EffectiveSchemaContext) schemaContext).getRootEffectiveStatements().size());
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
+import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.model.api.AnyXmlSchemaNode;
import org.opendaylight.yangtools.yang.model.api.AugmentationSchema;
import org.opendaylight.yangtools.yang.model.api.ChoiceCaseNode;
assertNotNull(gz);
assertNotNull(gzz);
- final QNameModule expectedModule = QNameModule.create(
- URI.create("urn:grouping:cascade-uses"), QName.parseRevision("2013-07-18"));
+ final QNameModule expectedModule = QNameModule.create(URI.create("urn:grouping:cascade-uses"),
+ Revision.valueOf("2013-07-18"));
SchemaPath expectedPath;
// grouping-U
import static org.opendaylight.yangtools.yang.stmt.StmtTestUtils.sourceForResource;
import java.net.URI;
-import java.util.Date;
import java.util.Optional;
import java.util.Set;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
+import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
private static void checkContentFullTest(final SchemaContext context) {
URI yangTypesNS = URI.create("urn:ietf:params:xml:ns:yang:ietf-yang-types");
- final Date rev20100924 = QName.parseRevision("2010-09-24");
- final Date rev20130516 = QName.parseRevision("2013-05-16");
- final Date rev20130715 = QName.parseRevision("2013-07-15");
+ final Revision rev20100924 = Revision.valueOf("2010-09-24");
+ final Revision rev20130516 = Revision.valueOf("2013-05-16");
+ final Revision rev20130715 = Revision.valueOf("2013-07-15");
final QNameModule yangTypes_20100924 = QNameModule.create(yangTypesNS, rev20100924);
final QNameModule yangTypes_20130516 = QNameModule.create(yangTypesNS, rev20130516);
checkInterfacesModuleFullTest(context, rev20100924, dateTimeTypeDef_20100924);
}
- private static void checkInterfacesModuleFullTest(final SchemaContext context, final Date rev20100924,
+ private static void checkInterfacesModuleFullTest(final SchemaContext context, final Revision rev20100924,
final QName dateTimeTypeDef_20100924) {
- Date rev20121115 = QName.parseRevision("2012-11-15");
+ Revision rev20121115 = Revision.valueOf("2012-11-15");
Module interfacesModule_20121115 = context.findModule("ietf-interfaces", rev20121115).get();
Set<ModuleImport> imports = interfacesModule_20121115.getImports();
}
private static void checkNetconfMonitoringModuleFullTest(final SchemaContext context,
- final Date rev20130715, final QName dateTimeTypeDef_20130715) {
- Date rev20101004 = QName.parseRevision("2010-10-04");
+ final Revision rev20130715, final QName dateTimeTypeDef_20130715) {
+ Revision rev20101004 = Revision.valueOf("2010-10-04");
Module monitoringModule_20101004 = context.findModule("ietf-netconf-monitoring", rev20101004).get();
Set<ModuleImport> imports = monitoringModule_20101004.getImports();
private static void checkContentSimpleTest(final SchemaContext context) {
URI yangTypesNS = URI.create("urn:ietf:params:xml:ns:yang:ietf-yang-types");
- final Date rev20100924 = QName.parseRevision("2010-09-24");
- final Date rev20130516 = QName.parseRevision("2013-05-16");
- final Date rev20130715 = QName.parseRevision("2013-07-15");
+ final Revision rev20100924 = Revision.valueOf("2010-09-24");
+ final Revision rev20130516 = Revision.valueOf("2013-05-16");
+ final Revision rev20130715 = Revision.valueOf("2013-07-15");
final QNameModule yangTypes_20100924 = QNameModule.create(yangTypesNS, rev20100924);
final QNameModule yangTypes_20130516 = QNameModule.create(yangTypesNS, rev20130516);
}
private static void checkInterfacesModuleSimpleTest(final SchemaContext context,
- final Date rev20100924, final QName dateTimeTypeDef_20100924) {
+ final Revision rev20100924, final QName dateTimeTypeDef_20100924) {
URI interfacesNS = URI.create("urn:ietf:params:xml:ns:yang:ietf-interfaces");
- Date rev20121115 = QName.parseRevision("2012-11-15");
+ Revision rev20121115 = Revision.valueOf("2012-11-15");
final QNameModule interfacesNS_20121115 = QNameModule.create(interfacesNS, rev20121115);
QName lastChange = QName.create(interfacesNS_20121115, "last-change");
}
private static void checkNetconfMonitoringModuleSimpleTest(final SchemaContext context,
- final Date rev20130715, final QName dateTimeTypeDef_20130715) {
+ final Revision rev20130715, final QName dateTimeTypeDef_20130715) {
URI monitoringNS = URI.create("urn:ietf:params:xml:ns:yang:ietf-netconf-monitoring");
final QNameModule monitoring_19700101 = QNameModule.create(monitoringNS);
QName lockedTime = QName.create(monitoring_19700101, "locked-time");
import java.util.Set;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.model.api.AnyXmlSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
import org.opendaylight.yangtools.yang.model.api.Module;
anyXml = (AnyXmlSchemaNode) output.getDataChildByName(QName.create(testModule.getQNameModule(), "data"));
assertNotNull(anyXml);
- final Module fooModule = result.findModule("foo", QName.parseRevision("2016-09-23")).get();
+ final Module fooModule = result.findModule("foo", Revision.valueOf("2016-09-23")).get();
final Set<RpcDefinition> rpcs = fooModule.getRpcs();
assertEquals(2, rpcs.size());
final SchemaContext schemaContext = StmtTestUtils.parseYangSource("/rpc-stmt-test/bar.yang");
assertNotNull(schemaContext);
- final Module barModule = schemaContext.findModule("bar", QName.parseRevision("2016-11-25")).get();
+ final Module barModule = schemaContext.findModule("bar", Revision.valueOf("2016-11-25")).get();
final Set<RpcDefinition> rpcs = barModule.getRpcs();
assertEquals(1, rpcs.size());
import org.junit.Before;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.model.api.IdentitySchemaNode;
import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
import org.opendaylight.yangtools.yang.model.api.Module;
QName testedTypeQName = testedType.getQName();
assertEquals(URI.create("urn:ietf:params:xml:ns:yang:iana-timezones"), testedTypeQName.getNamespace());
- assertEquals(Optional.of(QName.parseRevision("2012-07-09")), testedTypeQName.getRevision());
+ assertEquals(Optional.of(Revision.valueOf("2012-07-09")), testedTypeQName.getRevision());
assertEquals("iana-timezone", testedTypeQName.getLocalName());
EnumTypeDefinition enumType = (EnumTypeDefinition) testedType.getBaseType();
QName testedTypeQName = testedType.getQName();
assertEquals(URI.create("urn:ietf:params:xml:ns:yang:ietf-yang-types"), testedTypeQName.getNamespace());
- assertEquals(Optional.of(QName.parseRevision("2010-09-24")), testedTypeQName.getRevision());
+ assertEquals(Optional.of(Revision.valueOf("2010-09-24")), testedTypeQName.getRevision());
assertEquals("object-identifier-128", testedTypeQName.getLocalName());
StringTypeDefinition testedTypeBase = testedType.getBaseType();
QName testedTypeBaseQName = testedTypeBase.getQName();
assertEquals(URI.create("urn:ietf:params:xml:ns:yang:ietf-yang-types"), testedTypeBaseQName.getNamespace());
- assertEquals(Optional.of(QName.parseRevision("2010-09-24")), testedTypeBaseQName.getRevision());
+ assertEquals(Optional.of(Revision.valueOf("2010-09-24")), testedTypeBaseQName.getRevision());
assertEquals("object-identifier", testedTypeBaseQName.getLocalName());
}
IdentityrefTypeDefinition baseType = (IdentityrefTypeDefinition) testedType.getBaseType();
QName identity = baseType.getIdentity().getQName();
assertEquals(URI.create("urn:custom.types.demo"), identity.getNamespace());
- assertEquals(Optional.of(QName.parseRevision("2012-04-16")), identity.getRevision());
+ assertEquals(Optional.of(Revision.valueOf("2012-04-16")), identity.getRevision());
assertEquals("service-type", identity.getLocalName());
LeafSchemaNode type = (LeafSchemaNode) tested.getDataChildByName(QName.create(tested.getQNameModule(), "type"));
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
+import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.model.api.ChoiceSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
public class UsesAugmentTest {
private static final QNameModule UG = QNameModule.create(
- URI.create("urn:opendaylight:params:xml:ns:yang:uses-grouping"), QName.parseRevision("2013-07-30"));
+ URI.create("urn:opendaylight:params:xml:ns:yang:uses-grouping"), Revision.valueOf("2013-07-30"));
private static final QNameModule GD = QNameModule.create(
- URI.create("urn:opendaylight:params:xml:ns:yang:grouping-definitions"), QName.parseRevision("2013-09-04"));
+ URI.create("urn:opendaylight:params:xml:ns:yang:grouping-definitions"), Revision.valueOf("2013-09-04"));
private SchemaContext context;
import com.google.common.collect.ImmutableSet;
import java.net.URI;
-import java.util.Date;
import java.util.List;
import java.util.Set;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
+import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ExtensionDefinition;
import org.opendaylight.yangtools.yang.model.api.Module;
private static final StatementStreamSource IETF_RESTCONF_MODULE = sourceForResource(
"/yang-data-extension-test/ietf-restconf.yang");
- private static final Date REVISION = QName.parseRevision("2017-06-01");
+ private static final Revision REVISION = Revision.valueOf("2017-06-01");
private static final QNameModule FOO_QNAMEMODULE = QNameModule.create(URI.create("foo"), REVISION);
private static final QName MY_YANG_DATA_A = QName.create(FOO_QNAMEMODULE, "my-yang-data-a");
private static final QName MY_YANG_DATA_B = QName.create(FOO_QNAMEMODULE, "my-yang-data-b");
import java.net.URI;
import java.util.ArrayList;
-import java.util.Date;
import java.util.List;
import java.util.Set;
import org.junit.Before;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
+import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.model.api.AnyXmlSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ConstraintDefinition;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
import org.opendaylight.yangtools.yang.model.api.UsesNode;
public class YangParserSimpleTest {
- private static final QNameModule SN =
- QNameModule.create(URI.create("urn:opendaylight:simple-nodes"), QName.parseRevision("2013-07-30"));
+ private static final QNameModule SN = QNameModule.create(URI.create("urn:opendaylight:simple-nodes"),
+ Revision.valueOf("2013-07-30"));
private static final QName SN_NODES = QName.create(SN, "nodes");
private static final SchemaPath SN_NODES_PATH = SchemaPath.create(true, SN_NODES);
private static final URI NS = URI.create("urn:opendaylight:simple-nodes");
private static SchemaPath createPath(final String... names) {
- final Date rev = QName.parseRevision("2013-07-30");
+ final Revision rev = Revision.valueOf("2013-07-30");
final List<QName> path = new ArrayList<>();
for (final String name : names) {
path.add(QName.create(NS, rev, name));
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
+import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.common.YangConstants;
import org.opendaylight.yangtools.yang.common.YangVersion;
import org.opendaylight.yangtools.yang.model.api.AugmentationSchema;
public class YangParserTest {
private static final QNameModule FOO = QNameModule.create(
- URI.create("urn:opendaylight.foo"), QName.parseRevision("2013-02-27"));
+ URI.create("urn:opendaylight.foo"), Revision.valueOf("2013-02-27"));
private static final QNameModule BAR = QNameModule.create(
- URI.create("urn:opendaylight.bar"), QName.parseRevision("2013-07-03"));
+ URI.create("urn:opendaylight.bar"), Revision.valueOf("2013-07-03"));
private static final QNameModule BAZ = QNameModule.create(
- URI.create("urn:opendaylight.baz"), QName.parseRevision("2013-02-27"));
+ URI.create("urn:opendaylight.baz"), Revision.valueOf("2013-02-27"));
private SchemaContext context;
private Module foo;
assertEquals("opendaylight", foo.getOrganization());
assertEquals("http://www.opendaylight.org/", foo.getContact());
- assertEquals(Optional.of(QName.parseRevision("2013-02-27")), foo.getRevision());
+ assertEquals(Optional.of(Revision.valueOf("2013-02-27")), foo.getRevision());
assertNull(foo.getReference());
}
import com.google.common.collect.Iterables;
import java.net.URI;
import java.util.ArrayList;
-import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.model.api.AnyXmlSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ChoiceSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
private static final URI T1_NS = URI.create("urn:simple.demo.test1");
private static final URI T2_NS = URI.create("urn:simple.demo.test2");
private static final URI T3_NS = URI.create("urn:simple.demo.test3");
- private static final Date REV = QName.parseRevision("2013-06-18");
+ private static final Revision REV = Revision.valueOf("2013-06-18");
private static final StatementStreamSource BAR = sourceForResource("/model/bar.yang");
private static final StatementStreamSource BAZ = sourceForResource("/model/baz.yang");
final SchemaContext context = reactor.buildEffective();
- final Module module = context.findModule("test1", QName.parseRevision("2013-06-18")).get();
+ final Module module = context.findModule("test1", Revision.valueOf("2013-06-18")).get();
final LeafSchemaNode leaf = (LeafSchemaNode) module.getDataChildByName(QName.create(module.getQNameModule(),
"id"));
final UnsignedIntegerTypeDefinition leafType = (UnsignedIntegerTypeDefinition) leaf.getType();
QName qname = leafType.getQName();
assertEquals(URI.create("urn:simple.demo.test1"), qname.getNamespace());
- assertEquals(Optional.of(QName.parseRevision("2013-06-18")), qname.getRevision());
+ assertEquals(Optional.of(Revision.valueOf("2013-06-18")), qname.getRevision());
assertEquals("port-number", qname.getLocalName());
final UnsignedIntegerTypeDefinition leafBaseType = leafType.getBaseType();
qname = leafBaseType.getQName();
assertEquals(URI.create("urn:ietf:params:xml:ns:yang:ietf-inet-types"), qname.getNamespace());
- assertEquals(Optional.of(QName.parseRevision("2010-09-24")), qname.getRevision());
+ assertEquals(Optional.of(Revision.valueOf("2010-09-24")), qname.getRevision());
assertEquals("port-number", qname.getLocalName());
final UnsignedIntegerTypeDefinition dscpExt = (UnsignedIntegerTypeDefinition) TestUtils.findTypedef(
reactor.addSources(BAZ, FOO, BAR, SUBFOO, test2);
final SchemaContext context = reactor.buildEffective();
- final Module testModule = context.findModule("test2", QName.parseRevision("2013-06-18")).get();
+ final Module testModule = context.findModule("test2", Revision.valueOf("2013-06-18")).get();
final Module contextModule = context.findModules(URI.create("urn:opendaylight.baz")).iterator().next();
assertNotNull(contextModule);
final Set<GroupingDefinition> groupings = contextModule.getGroupings();
reactor.addSources(BAZ, FOO, BAR, SUBFOO, test2);
final SchemaContext context = reactor.buildEffective();
- final Module module = context.findModule("test2", QName.parseRevision("2013-06-18")).get();
+ final Module module = context.findModule("test2", Revision.valueOf("2013-06-18")).get();
final ContainerSchemaNode peer = (ContainerSchemaNode) module.getDataChildByName(QName.create(
module.getQNameModule(), "peer"));
final ContainerSchemaNode destination = (ContainerSchemaNode) peer.getDataChildByName(QName.create(
// test grouping path
final List<QName> path = new ArrayList<>();
- final QName qname = QName.create(URI.create("urn:opendaylight.baz"), QName.parseRevision("2013-02-27"),
- "target");
+ final QName qname = QName.create(URI.create("urn:opendaylight.baz"), Revision.valueOf("2013-02-27"), "target");
path.add(qname);
final SchemaPath expectedPath = SchemaPath.create(path, true);
assertEquals(expectedPath, usesNode.getGroupingPath());
reactor.addSources(types, test3);
final SchemaContext context = reactor.buildEffective();
- final Module module = context.findModule("test3", QName.parseRevision("2013-06-18")).get();
+ final Module module = context.findModule("test3", Revision.valueOf("2013-06-18")).get();
final Set<IdentitySchemaNode> identities = module.getIdentities();
assertEquals(1, identities.size());
final IdentitySchemaNode identity = identities.iterator().next();
final QName idQName = identity.getQName();
assertEquals(URI.create("urn:simple.demo.test3"), idQName.getNamespace());
- assertEquals(Optional.of(QName.parseRevision("2013-06-18")), idQName.getRevision());
+ assertEquals(Optional.of(Revision.valueOf("2013-06-18")), idQName.getRevision());
assertEquals("pt", idQName.getLocalName());
final IdentitySchemaNode baseIdentity = Iterables.getOnlyElement(identity.getBaseIdentities());
final QName idBaseQName = baseIdentity.getQName();
assertEquals(URI.create("urn:custom.types.demo"), idBaseQName.getNamespace());
- assertEquals(Optional.of(QName.parseRevision("2012-04-16")), idBaseQName.getRevision());
+ assertEquals(Optional.of(Revision.valueOf("2012-04-16")), idBaseQName.getRevision());
assertEquals("service-type", idBaseQName.getLocalName());
}
final SchemaContext context = reactor.buildEffective();
- final Module module = context.findModule("test3", QName.parseRevision("2013-06-18")).get();
+ final Module module = context.findModule("test3", Revision.valueOf("2013-06-18")).get();
final ContainerSchemaNode network = (ContainerSchemaNode) module.getDataChildByName(QName.create(
module.getQNameModule(), "network"));
final List<UnknownSchemaNode> unknownNodes = network.getUnknownSchemaNodes();
final UnknownSchemaNode un = unknownNodes.get(0);
final QName unType = un.getNodeType();
assertEquals(URI.create("urn:custom.types.demo"), unType.getNamespace());
- assertEquals(Optional.of(QName.parseRevision("2012-04-16")), unType.getRevision());
+ assertEquals(Optional.of(Revision.valueOf("2012-04-16")), unType.getRevision());
assertEquals("mountpoint", unType.getLocalName());
assertEquals("point", un.getNodeParameter());
assertNotNull(un.getExtensionDefinition());
reactor.addSources(bar, deviationTest);
final SchemaContext context = reactor.buildEffective();
- final Module testModule = context.findModule("deviation-test", QName.parseRevision("2013-02-27")).get();
+ final Module testModule = context.findModule("deviation-test", Revision.valueOf("2013-02-27")).get();
final Set<Deviation> deviations = testModule.getDeviations();
assertEquals(1, deviations.size());
final Deviation dev = deviations.iterator().next();
assertEquals("system/user ref", dev.getReference());
final URI expectedNS = URI.create("urn:opendaylight.bar");
- final Date expectedRev = QName.parseRevision("2013-07-03");
+ final Revision expectedRev = Revision.valueOf("2013-07-03");
final List<QName> path = new ArrayList<>();
path.add(QName.create(expectedNS, expectedRev, "interfaces"));
path.add(QName.create(expectedNS, expectedRev, "ifEntry"));
import com.google.common.base.MoreObjects;
import com.google.common.base.MoreObjects.ToStringHelper;
import javax.annotation.Nonnull;
+import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.model.api.ModuleIdentifier;
/**
@Override
public ModuleIdentifier select(final ModuleIdentifier first, final ModuleIdentifier second) {
- return ModuleIdentifier.compareRevisions(first.getRevision(), second.getRevision()) >= 0 ? first : second;
+ return Revision.compare(first.getRevision(), second.getRevision()) >= 0 ? first : second;
}
@Override
import com.google.common.base.Strings;
import com.google.common.collect.ImmutableList;
import java.util.Collection;
-import java.util.Date;
+import java.util.Optional;
import java.util.Set;
import java.util.function.Predicate;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
-import org.opendaylight.yangtools.yang.common.SimpleDateFormatUtil;
+import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.common.YangVersion;
import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
}
// creates SourceIdentifier for a submodule
- final Date revision = getLatestRevision(root.declaredSubstatements());
- return revision == null ? RevisionSourceIdentifier.create((String) root.getStatementArgument())
- : RevisionSourceIdentifier.create((String) root.getStatementArgument(),
- SimpleDateFormatUtil.getRevisionFormat().format(revision));
+ final Optional<Revision> revision = getLatestRevision(root.declaredSubstatements());
+ return revision.isPresent()
+ ? RevisionSourceIdentifier.create((String) root.getStatementArgument(), revision.get().toString())
+ : RevisionSourceIdentifier.create((String) root.getStatementArgument());
}
- public static Date getLatestRevision(final Iterable<? extends StmtContext<?, ?, ?>> subStmts) {
- Date revision = null;
+ public static Optional<Revision> getLatestRevision(final Iterable<? extends StmtContext<?, ?, ?>> subStmts) {
+ Revision revision = null;
for (final StmtContext<?, ?, ?> subStmt : subStmts) {
if (subStmt.getPublicDefinition().getDeclaredRepresentationClass().isAssignableFrom(
RevisionStatement.class)) {
if (revision == null && subStmt.getStatementArgument() != null) {
- revision = (Date) subStmt.getStatementArgument();
+ revision = (Revision) subStmt.getStatementArgument();
} else if (subStmt.getStatementArgument() != null
- && ((Date) subStmt.getStatementArgument()).compareTo(revision) > 0) {
- revision = (Date) subStmt.getStatementArgument();
+ && ((Revision) subStmt.getStatementArgument()).compareTo(revision) > 0) {
+ revision = (Revision) subStmt.getStatementArgument();
}
}
}
- return revision;
+ return Optional.ofNullable(revision);
}
}
Code Review / yangtools.git / commitdiff