service/simulator/java/sdk/src/org/oic/simulator/ArrayValueValidator.java

   1 /*
   2  * Copyright 2015 Samsung Electronics All Rights Reserved.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 package org.oic.simulator;
  18
  19 import java.util.HashSet;
  20 import java.util.Set;
  21
  22 class ArrayValueValidator implements
  23         AttributeValueVisitor.VisitingMethods<Boolean> {
  24
  25     private ArrayProperty mProperty = null;
  26
  27     ArrayValueValidator(ArrayProperty property) {
  28         mProperty = property;
  29     }
  30
  31     public boolean validate(AttributeValue value) {
  32         AttributeValueVisitor visitor = new AttributeValueVisitor(value, this);
  33         return (Boolean) visitor.visit();
  34     }
  35
  36     @Override
  37     public Boolean visitingValue(Integer value) {
  38         return false;
  39     }
  40
  41     @Override
  42     public Boolean visitingValue(Double value) {
  43         return false;
  44     }
  45
  46     @Override
  47     public Boolean visitingValue(Boolean value) {
  48         return false;
  49     }
  50
  51     @Override
  52     public Boolean visitingValue(String value) {
  53         return false;
  54     }
  55
  56     @Override
  57     public Boolean visitingValue(SimulatorResourceModel value) {
  58         return false;
  59     }
  60
  61     @Override
  62     public Boolean visitingValue(Integer[] values) {
  63         if (null == mProperty)
  64             return false;
  65
  66         // Validating length of array
  67         if (mProperty.hasRange()) {
  68             if (values.length < mProperty.minItems()
  69                     || (values.length > mProperty.maxItems() && !mProperty
  70                             .isVariable())) {
  71                 return false;
  72             }
  73         }
  74
  75         // Validating elements of array
  76         AttributeProperty elementProperty = mProperty.getElementProperty();
  77         if (!elementProperty.isInteger()) {
  78             return false;
  79         }
  80
  81         Set<Integer> uniqueSet = new HashSet<Integer>();
  82         for (Integer value : values) {
  83             if (mProperty.isUnique() && uniqueSet.add(value) == false) {
  84                 return false;
  85             }
  86
  87             if (false == elementProperty.asInteger().validate(value))
  88                 return false;
  89         }
  90
  91         return true;
  92     }
  93
  94     @Override
  95     public Boolean visitingValue(Double[] values) {
  96         if (null == mProperty)
  97             return false;
  98
  99         // Validating length of array
 100         if (mProperty.hasRange()) {
 101             if (values.length < mProperty.minItems()
 102                     || (values.length > mProperty.maxItems() && !mProperty
 103                             .isVariable())) {
 104                 return false;
 105             }
 106         }
 107
 108         // Validating elements of array
 109         AttributeProperty elementProperty = mProperty.getElementProperty();
 110         if (!elementProperty.isDouble()) {
 111             return false;
 112         }
 113
 114         Set<Double> uniqueSet = new HashSet<Double>();
 115         for (Double value : values) {
 116             if (mProperty.isUnique() && uniqueSet.add(value) == false) {
 117                 return false;
 118             }
 119
 120             if (false == elementProperty.asDouble().validate(value))
 121                 return false;
 122         }
 123
 124         return true;
 125     }
 126
 127     @Override
 128     public Boolean visitingValue(Boolean[] values) {
 129         if (null == mProperty)
 130             return false;
 131
 132         // Validating length of array
 133         if (mProperty.hasRange()) {
 134             if (values.length < mProperty.minItems()
 135                     || (values.length > mProperty.maxItems() && !mProperty
 136                             .isVariable())) {
 137                 return false;
 138             }
 139         }
 140
 141         // Validating elements of array
 142         AttributeProperty elementProperty = mProperty.getElementProperty();
 143         if (!elementProperty.isBoolean()) {
 144             return false;
 145         }
 146
 147         Set<Boolean> uniqueSet = new HashSet<Boolean>();
 148         for (Boolean value : values) {
 149             if (mProperty.isUnique() && uniqueSet.add(value) == false) {
 150                 return false;
 151             }
 152
 153             if (false == elementProperty.asBoolean().validate(value))
 154                 return false;
 155         }
 156
 157         return true;
 158     }
 159
 160     @Override
 161     public Boolean visitingValue(String[] values) {
 162         if (null == mProperty)
 163             return false;
 164
 165         // Validating length of array
 166         if (mProperty.hasRange()) {
 167             if (values.length < mProperty.minItems()
 168                     || (values.length > mProperty.maxItems() && !mProperty
 169                             .isVariable())) {
 170                 return false;
 171             }
 172         }
 173
 174         // Validating elements of array
 175         AttributeProperty elementProperty = mProperty.getElementProperty();
 176         if (!elementProperty.isString()) {
 177             return false;
 178         }
 179
 180         Set<String> uniqueSet = new HashSet<String>();
 181         for (String value : values) {
 182             if (mProperty.isUnique() && uniqueSet.add(value) == false) {
 183                 return false;
 184             }
 185
 186             if (false == elementProperty.asString().validate(value))
 187                 return false;
 188         }
 189
 190         return true;
 191     }
 192
 193     @Override
 194     public Boolean visitingValue(SimulatorResourceModel[] values) {
 195         if (null == mProperty)
 196             return false;
 197
 198         // Validating length of array
 199         if (mProperty.hasRange()) {
 200             if (values.length < mProperty.minItems()
 201                     || (values.length > mProperty.maxItems() && !mProperty
 202                             .isVariable())) {
 203                 return false;
 204             }
 205         }
 206
 207         // Validating elements of array
 208         AttributeProperty elementProperty = mProperty.getElementProperty();
 209         if (!elementProperty.isInteger()) {
 210             return false;
 211         }
 212
 213         for (SimulatorResourceModel value : values) {
 214             if (false == elementProperty.asModel().validate(value))
 215                 return false;
 216         }
 217
 218         return true;
 219     }
 220
 221     @Override
 222     public Boolean visitingValue(Integer[][] values) {
 223         if (null == mProperty)
 224             return false;
 225
 226         // Validating length of array
 227         if (mProperty.hasRange()) {
 228             if (values.length < mProperty.minItems()
 229                     || (values.length > mProperty.maxItems() && !mProperty
 230                             .isVariable())) {
 231                 return false;
 232             }
 233         }
 234
 235         // Validating elements of array
 236         AttributeProperty elementProperty = mProperty.getElementProperty();
 237         if (!elementProperty.isArray()) {
 238             return false;
 239         }
 240
 241         ArrayValueValidator validator = new ArrayValueValidator(
 242                 elementProperty.asArray());
 243         for (Integer[] value : values) {
 244             if (false == validator.visitingValue(value))
 245                 return false;
 246         }
 247
 248         return true;
 249     }
 250
 251     @Override
 252     public Boolean visitingValue(Double[][] values) {
 253         if (null == mProperty)
 254             return false;
 255
 256         // Validating length of array
 257         if (mProperty.hasRange()) {
 258             if (values.length < mProperty.minItems()
 259                     || (values.length > mProperty.maxItems() && !mProperty
 260                             .isVariable())) {
 261                 return false;
 262             }
 263         }
 264
 265         // Validating elements of array
 266         AttributeProperty elementProperty = mProperty.getElementProperty();
 267         if (!elementProperty.isArray()) {
 268             return false;
 269         }
 270
 271         ArrayValueValidator validator = new ArrayValueValidator(
 272                 elementProperty.asArray());
 273         for (Double[] value : values) {
 274             if (false == validator.visitingValue(value))
 275                 return false;
 276         }
 277
 278         return true;
 279     }
 280
 281     @Override
 282     public Boolean visitingValue(Boolean[][] values) {
 283         if (null == mProperty)
 284             return false;
 285
 286         // Validating length of array
 287         if (mProperty.hasRange()) {
 288             if (values.length < mProperty.minItems()
 289                     || (values.length > mProperty.maxItems() && !mProperty
 290                             .isVariable())) {
 291                 return false;
 292             }
 293         }
 294
 295         // Validating elements of array
 296         AttributeProperty elementProperty = mProperty.getElementProperty();
 297         if (!elementProperty.isArray()) {
 298             return false;
 299         }
 300
 301         ArrayValueValidator validator = new ArrayValueValidator(
 302                 elementProperty.asArray());
 303         for (Boolean[] value : values) {
 304             if (false == validator.visitingValue(value))
 305                 return false;
 306         }
 307
 308         return true;
 309     }
 310
 311     @Override
 312     public Boolean visitingValue(String[][] values) {
 313         if (null == mProperty)
 314             return false;
 315
 316         // Validating length of array
 317         if (mProperty.hasRange()) {
 318             if (values.length < mProperty.minItems()
 319                     || (values.length > mProperty.maxItems() && !mProperty
 320                             .isVariable())) {
 321                 return false;
 322             }
 323         }
 324
 325         // Validating elements of array
 326         AttributeProperty elementProperty = mProperty.getElementProperty();
 327         if (!elementProperty.isArray()) {
 328             return false;
 329         }
 330
 331         ArrayValueValidator validator = new ArrayValueValidator(
 332                 elementProperty.asArray());
 333         for (String[] value : values) {
 334             if (false == validator.visitingValue(value))
 335                 return false;
 336         }
 337
 338         return true;
 339     }
 340
 341     @Override
 342     public Boolean visitingValue(SimulatorResourceModel[][] values) {
 343         if (null == mProperty)
 344             return false;
 345
 346         // Validating length of array
 347         if (mProperty.hasRange()) {
 348             if (values.length < mProperty.minItems()
 349                     || (values.length > mProperty.maxItems() && !mProperty
 350                             .isVariable())) {
 351                 return false;
 352             }
 353         }
 354
 355         // Validating elements of array
 356         AttributeProperty elementProperty = mProperty.getElementProperty();
 357         if (!elementProperty.isArray()) {
 358             return false;
 359         }
 360
 361         ArrayValueValidator validator = new ArrayValueValidator(
 362                 elementProperty.asArray());
 363         for (SimulatorResourceModel[] value : values) {
 364             if (false == validator.visitingValue(value))
 365                 return false;
 366         }
 367
 368         return true;
 369     }
 370
 371     @Override
 372     public Boolean visitingValue(Integer[][][] values) {
 373         if (null == mProperty)
 374             return false;
 375
 376         // Validating length of array
 377         if (mProperty.hasRange()) {
 378             if (values.length < mProperty.minItems()
 379                     || (values.length > mProperty.maxItems() && !mProperty
 380                             .isVariable())) {
 381                 return false;
 382             }
 383         }
 384
 385         // Validating elements of array
 386         AttributeProperty elementProperty = mProperty.getElementProperty();
 387         if (!elementProperty.isArray()) {
 388             return false;
 389         }
 390
 391         ArrayValueValidator validator = new ArrayValueValidator(
 392                 elementProperty.asArray());
 393         for (Integer[][] value : values) {
 394             if (false == validator.visitingValue(value))
 395                 return false;
 396         }
 397
 398         return true;
 399     }
 400
 401     @Override
 402     public Boolean visitingValue(Double[][][] values) {
 403         if (null == mProperty)
 404             return false;
 405
 406         // Validating length of array
 407         if (mProperty.hasRange()) {
 408             if (values.length < mProperty.minItems()
 409                     || (values.length > mProperty.maxItems() && !mProperty
 410                             .isVariable())) {
 411                 return false;
 412             }
 413         }
 414
 415         // Validating elements of array
 416         AttributeProperty elementProperty = mProperty.getElementProperty();
 417         if (!elementProperty.isArray()) {
 418             return false;
 419         }
 420
 421         ArrayValueValidator validator = new ArrayValueValidator(
 422                 elementProperty.asArray());
 423         for (Double[][] value : values) {
 424             if (false == validator.visitingValue(value))
 425                 return false;
 426         }
 427
 428         return true;
 429     }
 430
 431     @Override
 432     public Boolean visitingValue(Boolean[][][] values) {
 433         if (null == mProperty)
 434             return false;
 435
 436         // Validating length of array
 437         if (mProperty.hasRange()) {
 438             if (values.length < mProperty.minItems()
 439                     || (values.length > mProperty.maxItems() && !mProperty
 440                             .isVariable())) {
 441                 return false;
 442             }
 443         }
 444
 445         // Validating elements of array
 446         AttributeProperty elementProperty = mProperty.getElementProperty();
 447         if (!elementProperty.isArray()) {
 448             return false;
 449         }
 450
 451         ArrayValueValidator validator = new ArrayValueValidator(
 452                 elementProperty.asArray());
 453         for (Boolean[][] value : values) {
 454             if (false == validator.visitingValue(value))
 455                 return false;
 456         }
 457
 458         return true;
 459     }
 460
 461     @Override
 462     public Boolean visitingValue(String[][][] values) {
 463         if (null == mProperty)
 464             return false;
 465
 466         // Validating length of array
 467         if (mProperty.hasRange()) {
 468             if (values.length < mProperty.minItems()
 469                     || (values.length > mProperty.maxItems() && !mProperty
 470                             .isVariable())) {
 471                 return false;
 472             }
 473         }
 474
 475         // Validating elements of array
 476         AttributeProperty elementProperty = mProperty.getElementProperty();
 477         if (!elementProperty.isArray()) {
 478             return false;
 479         }
 480
 481         ArrayValueValidator validator = new ArrayValueValidator(
 482                 elementProperty.asArray());
 483         for (String[][] value : values) {
 484             if (false == validator.visitingValue(value))
 485                 return false;
 486         }
 487
 488         return true;
 489     }
 490
 491     @Override
 492     public Boolean visitingValue(SimulatorResourceModel[][][] values) {
 493         if (null == mProperty)
 494             return false;
 495
 496         // Validating length of array
 497         if (mProperty.hasRange()) {
 498             if (values.length < mProperty.minItems()
 499                     || (values.length > mProperty.maxItems() && !mProperty
 500                             .isVariable())) {
 501                 return false;
 502             }
 503         }
 504
 505         // Validating elements of array
 506         AttributeProperty elementProperty = mProperty.getElementProperty();
 507         if (!elementProperty.isArray()) {
 508             return false;
 509         }
 510
 511         ArrayValueValidator validator = new ArrayValueValidator(
 512                 elementProperty.asArray());
 513         for (SimulatorResourceModel[][] value : values) {
 514             if (false == validator.visitingValue(value))
 515                 return false;
 516         }
 517
 518         return true;
 519     }
 520 }