Split out yang-model-ri
[yangtools.git] / yang / yang-parser-rfc7950 / src / main / java / org / opendaylight / yangtools / yang / parser / rfc7950 / stmt / range / RangeStatementSupport.java
1 /*
2  * Copyright (c) 2017 Pantheon Technologies, s.r.o. and others.  All rights reserved.
3  *
4  * This program and the accompanying materials are made available under the
5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
6  * and is available at http://www.eclipse.org/legal/epl-v10.html
7  */
8 package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.range;
9
10 import com.google.common.collect.ImmutableList;
11 import com.google.common.collect.Iterables;
12 import java.math.BigDecimal;
13 import java.util.ArrayList;
14 import java.util.Iterator;
15 import java.util.List;
16 import org.eclipse.jdt.annotation.NonNull;
17 import org.opendaylight.yangtools.yang.common.Uint64;
18 import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
19 import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
20 import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
21 import org.opendaylight.yangtools.yang.model.api.stmt.RangeEffectiveStatement;
22 import org.opendaylight.yangtools.yang.model.api.stmt.RangeStatement;
23 import org.opendaylight.yangtools.yang.model.api.stmt.UnresolvedNumber;
24 import org.opendaylight.yangtools.yang.model.api.stmt.ValueRange;
25 import org.opendaylight.yangtools.yang.model.ri.stmt.DeclaredStatements;
26 import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.ArgumentUtils;
27 import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
28 import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
29 import org.opendaylight.yangtools.yang.parser.spi.meta.InferenceException;
30 import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
31 import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
32 import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
33
34 public final class RangeStatementSupport
35         extends AbstractStatementSupport<List<ValueRange>, RangeStatement, RangeEffectiveStatement> {
36     private static final SubstatementValidator SUBSTATEMENT_VALIDATOR =
37         SubstatementValidator.builder(YangStmtMapping.RANGE)
38             .addOptional(YangStmtMapping.DESCRIPTION)
39             .addOptional(YangStmtMapping.ERROR_APP_TAG)
40             .addOptional(YangStmtMapping.ERROR_MESSAGE)
41             .addOptional(YangStmtMapping.REFERENCE)
42             .build();
43     private static final RangeStatementSupport INSTANCE = new RangeStatementSupport();
44
45     private RangeStatementSupport() {
46         super(YangStmtMapping.RANGE, StatementPolicy.contextIndependent());
47     }
48
49     public static RangeStatementSupport getInstance() {
50         return INSTANCE;
51     }
52
53     @Override
54     public ImmutableList<ValueRange> parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String rangeArgument) {
55         final List<ValueRange> ranges = new ArrayList<>();
56
57         for (final String singleRange : ArgumentUtils.PIPE_SPLITTER.split(rangeArgument)) {
58             final Iterator<String> boundaries = ArgumentUtils.TWO_DOTS_SPLITTER.split(singleRange).iterator();
59             final Number min = parseDecimalConstraintValue(ctx, boundaries.next());
60
61             final Number max;
62             if (boundaries.hasNext()) {
63                 max = parseDecimalConstraintValue(ctx, boundaries.next());
64
65                 // if min larger than max then error
66                 SourceException.throwIf(ArgumentUtils.compareNumbers(min, max) == 1, ctx,
67                     "Range constraint %s has descending order of boundaries; should be ascending", singleRange);
68                 SourceException.throwIf(boundaries.hasNext(), ctx,
69                     "Wrong number of boundaries in range constraint %s", singleRange);
70             } else {
71                 max = min;
72             }
73
74             // some of intervals overlapping
75             InferenceException.throwIf(
76                 ranges.size() > 1 && ArgumentUtils.compareNumbers(min, Iterables.getLast(ranges).upperBound()) != 1,
77                 ctx, "Some of the value ranges in %s are not disjoint", rangeArgument);
78             ranges.add(ValueRange.of(min, max));
79         }
80
81         return ImmutableList.copyOf(ranges);
82     }
83
84     @Override
85     protected RangeStatement createDeclared(final StmtContext<List<ValueRange>, RangeStatement, ?> ctx,
86             final ImmutableList<? extends DeclaredStatement<?>> substatements) {
87         return DeclaredStatements.createRange(ctx.getRawArgument(), ctx.getArgument(), substatements);
88     }
89
90     @Override
91     protected RangeStatement createEmptyDeclared(final StmtContext<List<ValueRange>, RangeStatement, ?> ctx) {
92         return DeclaredStatements.createRange(ctx.getRawArgument(), ctx.getArgument());
93     }
94
95     @Override
96     protected RangeEffectiveStatement createEffective(final Current<List<ValueRange>, RangeStatement> stmt,
97             final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
98         return substatements.isEmpty() ? new EmptyRangeEffectiveStatement(stmt.declared())
99             : new RegularRangeEffectiveStatement(stmt.declared(), substatements);
100     }
101
102     @Override
103     protected SubstatementValidator getSubstatementValidator() {
104         return SUBSTATEMENT_VALIDATOR;
105     }
106
107     private static @NonNull Number parseDecimalConstraintValue(final @NonNull StmtContext<?, ?, ?> ctx,
108             final @NonNull String value) {
109         if ("max".equals(value)) {
110             return UnresolvedNumber.max();
111         }
112         if ("min".equals(value)) {
113             return UnresolvedNumber.min();
114         }
115         // Deal with decimal64, i.e. 'decimal-value' production of the RFC6020 ABNF
116         if (value.indexOf('.') != -1) {
117             try {
118                 // FIXME: YANGTOOLS-556: Use Decimal64 here
119                 return new BigDecimal(value);
120             } catch (NumberFormatException e) {
121                 throw new SourceException(ctx, e, "Value %s is not a valid decimal number", value);
122             }
123         }
124
125         // This has to be an 'integer-value' production of the RFC6020 ABNF. We also clamp allowed range to Long/Uint,
126         // as that is the effectively-valid range of allowed values. For Uint64 we also try to intern the value.
127         try {
128             return value.startsWith("-") ? Long.valueOf(value) : Uint64.valueOf(value).intern();
129         } catch (IllegalArgumentException e) {
130             throw new SourceException(ctx, e, "Value %s is not a valid integral range number", value);
131         }
132     }
133 }