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