1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27 package gov.nist.secauto.metaschema.core.model.constraint;
28
29 import gov.nist.secauto.metaschema.core.datatype.IDataTypeAdapter;
30 import gov.nist.secauto.metaschema.core.datatype.markup.MarkupLine;
31 import gov.nist.secauto.metaschema.core.datatype.markup.MarkupMultiline;
32 import gov.nist.secauto.metaschema.core.metapath.MetapathExpression;
33 import gov.nist.secauto.metaschema.core.util.ObjectUtils;
34
35 import java.util.Map;
36 import java.util.Set;
37 import java.util.regex.Pattern;
38
39 import javax.xml.namespace.QName;
40
41 import edu.umd.cs.findbugs.annotations.NonNull;
42 import edu.umd.cs.findbugs.annotations.Nullable;
43
44 public final class DefaultMatchesConstraint
45 extends AbstractConstraint
46 implements IMatchesConstraint {
47 private final Pattern pattern;
48 private final IDataTypeAdapter<?> dataType;
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78 private DefaultMatchesConstraint(
79 @Nullable String id,
80 @Nullable String formalName,
81 @Nullable MarkupLine description,
82 @NonNull ISource source,
83 @NonNull Level level,
84 @NonNull MetapathExpression target,
85 @NonNull Map<QName, Set<String>> properties,
86 @Nullable Pattern pattern,
87 @Nullable IDataTypeAdapter<?> dataType,
88 @Nullable MarkupMultiline remarks) {
89 super(id, formalName, description, source, level, target, properties, remarks);
90 if (pattern == null && dataType == null) {
91 throw new IllegalArgumentException("a pattern or data type must be provided");
92 }
93 this.pattern = pattern;
94 this.dataType = dataType;
95 }
96
97 @Override
98 public Pattern getPattern() {
99 return pattern;
100 }
101
102 @Override
103 public IDataTypeAdapter<?> getDataType() {
104 return dataType;
105 }
106
107 @Override
108 public <T, R> R accept(IConstraintVisitor<T, R> visitor, T state) {
109 return visitor.visitMatchesConstraint(this, state);
110 }
111
112 @NonNull
113 public static Builder builder() {
114 return new Builder();
115 }
116
117 public static final class Builder
118 extends AbstractConstraintBuilder<Builder, DefaultMatchesConstraint> {
119 private Pattern pattern;
120 private IDataTypeAdapter<?> datatype;
121
122 private Builder() {
123
124 }
125
126 public Builder regex(@NonNull String pattern) {
127 return regex(ObjectUtils.notNull(Pattern.compile(pattern)));
128 }
129
130 public Builder regex(@NonNull Pattern pattern) {
131 this.pattern = pattern;
132 return this;
133 }
134
135 public Builder datatype(@NonNull IDataTypeAdapter<?> datatype) {
136 this.datatype = datatype;
137 return this;
138 }
139
140 @Override
141 protected Builder getThis() {
142 return this;
143 }
144
145 @Override
146 protected void validate() {
147 super.validate();
148
149 if (getPattern() == null && getDatatype() == null) {
150 throw new IllegalStateException("A pattern or data type must be provided at minimum.");
151 }
152 }
153
154 protected Pattern getPattern() {
155 return pattern;
156 }
157
158 protected IDataTypeAdapter<?> getDatatype() {
159 return datatype;
160 }
161
162 @Override
163 protected DefaultMatchesConstraint newInstance() {
164 return new DefaultMatchesConstraint(
165 getId(),
166 getFormalName(),
167 getDescription(),
168 ObjectUtils.notNull(getSource()),
169 getLevel(),
170 getTarget(),
171 getProperties(),
172 getPattern(),
173 getDatatype(),
174 getRemarks());
175 }
176 }
177 }