1 /* 2 * Copyright (C) 2017 The Android Open Source Project 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 android.location.cts.asn1.supl2.ver2_ulp_components; 18 19 /* 20 */ 21 22 23 // 24 // 25 import android.location.cts.asn1.base.Asn1Integer; 26 import android.location.cts.asn1.base.Asn1Null; 27 import android.location.cts.asn1.base.Asn1Object; 28 import android.location.cts.asn1.base.Asn1Sequence; 29 import android.location.cts.asn1.base.Asn1Tag; 30 import android.location.cts.asn1.base.BitStream; 31 import android.location.cts.asn1.base.BitStreamReader; 32 import android.location.cts.asn1.base.SequenceComponent; 33 import com.google.common.collect.ImmutableList; 34 import java.util.Collection; 35 import javax.annotation.Nullable; 36 37 38 /** 39 */ 40 public class CircularArea extends Asn1Sequence { 41 // 42 43 private static final Asn1Tag TAG_CircularArea 44 = Asn1Tag.fromClassAndNumber(-1, -1); 45 46 public CircularArea() { 47 super(); 48 } 49 50 @Override 51 @Nullable 52 protected Asn1Tag getTag() { 53 return TAG_CircularArea; 54 } 55 56 @Override 57 protected boolean isTagImplicit() { 58 return true; 59 } 60 61 public static Collection<Asn1Tag> getPossibleFirstTags() { 62 if (TAG_CircularArea != null) { 63 return ImmutableList.of(TAG_CircularArea); 64 } else { 65 return Asn1Sequence.getPossibleFirstTags(); 66 } 67 } 68 69 /** 70 * Creates a new CircularArea from encoded stream. 71 */ 72 public static CircularArea fromPerUnaligned(byte[] encodedBytes) { 73 CircularArea result = new CircularArea(); 74 result.decodePerUnaligned(new BitStreamReader(encodedBytes)); 75 return result; 76 } 77 78 /** 79 * Creates a new CircularArea from encoded stream. 80 */ 81 public static CircularArea fromPerAligned(byte[] encodedBytes) { 82 CircularArea result = new CircularArea(); 83 result.decodePerAligned(new BitStreamReader(encodedBytes)); 84 return result; 85 } 86 87 88 89 @Override protected boolean isExtensible() { 90 return false; 91 } 92 93 @Override public boolean containsExtensionValues() { 94 for (SequenceComponent extensionComponent : getExtensionComponents()) { 95 if (extensionComponent.isExplicitlySet()) return true; 96 } 97 return false; 98 } 99 100 101 private Coordinate coordinate_; 102 public Coordinate getCoordinate() { 103 return coordinate_; 104 } 105 /** 106 * @throws ClassCastException if value is not a Coordinate 107 */ 108 public void setCoordinate(Asn1Object value) { 109 this.coordinate_ = (Coordinate) value; 110 } 111 public Coordinate setCoordinateToNewInstance() { 112 coordinate_ = new Coordinate(); 113 return coordinate_; 114 } 115 116 private CircularArea.radiusType radius_; 117 public CircularArea.radiusType getRadius() { 118 return radius_; 119 } 120 /** 121 * @throws ClassCastException if value is not a CircularArea.radiusType 122 */ 123 public void setRadius(Asn1Object value) { 124 this.radius_ = (CircularArea.radiusType) value; 125 } 126 public CircularArea.radiusType setRadiusToNewInstance() { 127 radius_ = new CircularArea.radiusType(); 128 return radius_; 129 } 130 131 private CircularArea.radius_minType radius_min_; 132 public CircularArea.radius_minType getRadius_min() { 133 return radius_min_; 134 } 135 /** 136 * @throws ClassCastException if value is not a CircularArea.radius_minType 137 */ 138 public void setRadius_min(Asn1Object value) { 139 this.radius_min_ = (CircularArea.radius_minType) value; 140 } 141 public CircularArea.radius_minType setRadius_minToNewInstance() { 142 radius_min_ = new CircularArea.radius_minType(); 143 return radius_min_; 144 } 145 146 private CircularArea.radius_maxType radius_max_; 147 public CircularArea.radius_maxType getRadius_max() { 148 return radius_max_; 149 } 150 /** 151 * @throws ClassCastException if value is not a CircularArea.radius_maxType 152 */ 153 public void setRadius_max(Asn1Object value) { 154 this.radius_max_ = (CircularArea.radius_maxType) value; 155 } 156 public CircularArea.radius_maxType setRadius_maxToNewInstance() { 157 radius_max_ = new CircularArea.radius_maxType(); 158 return radius_max_; 159 } 160 161 162 163 164 165 166 @Override public Iterable<? extends SequenceComponent> getComponents() { 167 ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder(); 168 169 builder.add(new SequenceComponent() { 170 Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0); 171 172 @Override public boolean isExplicitlySet() { 173 return getCoordinate() != null; 174 } 175 176 @Override public boolean hasDefaultValue() { 177 return false; 178 } 179 180 @Override public boolean isOptional() { 181 return false; 182 } 183 184 @Override public Asn1Object getComponentValue() { 185 return getCoordinate(); 186 } 187 188 @Override public void setToNewInstance() { 189 setCoordinateToNewInstance(); 190 } 191 192 @Override public Collection<Asn1Tag> getPossibleFirstTags() { 193 return tag == null ? Coordinate.getPossibleFirstTags() : ImmutableList.of(tag); 194 } 195 196 @Override 197 public Asn1Tag getTag() { 198 return tag; 199 } 200 201 @Override 202 public boolean isImplicitTagging() { 203 return true; 204 } 205 206 @Override public String toIndentedString(String indent) { 207 return "coordinate : " 208 + getCoordinate().toIndentedString(indent); 209 } 210 }); 211 212 builder.add(new SequenceComponent() { 213 Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1); 214 215 @Override public boolean isExplicitlySet() { 216 return getRadius() != null; 217 } 218 219 @Override public boolean hasDefaultValue() { 220 return false; 221 } 222 223 @Override public boolean isOptional() { 224 return false; 225 } 226 227 @Override public Asn1Object getComponentValue() { 228 return getRadius(); 229 } 230 231 @Override public void setToNewInstance() { 232 setRadiusToNewInstance(); 233 } 234 235 @Override public Collection<Asn1Tag> getPossibleFirstTags() { 236 return tag == null ? CircularArea.radiusType.getPossibleFirstTags() : ImmutableList.of(tag); 237 } 238 239 @Override 240 public Asn1Tag getTag() { 241 return tag; 242 } 243 244 @Override 245 public boolean isImplicitTagging() { 246 return true; 247 } 248 249 @Override public String toIndentedString(String indent) { 250 return "radius : " 251 + getRadius().toIndentedString(indent); 252 } 253 }); 254 255 builder.add(new SequenceComponent() { 256 Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2); 257 258 @Override public boolean isExplicitlySet() { 259 return getRadius_min() != null; 260 } 261 262 @Override public boolean hasDefaultValue() { 263 return false; 264 } 265 266 @Override public boolean isOptional() { 267 return true; 268 } 269 270 @Override public Asn1Object getComponentValue() { 271 return getRadius_min(); 272 } 273 274 @Override public void setToNewInstance() { 275 setRadius_minToNewInstance(); 276 } 277 278 @Override public Collection<Asn1Tag> getPossibleFirstTags() { 279 return tag == null ? CircularArea.radius_minType.getPossibleFirstTags() : ImmutableList.of(tag); 280 } 281 282 @Override 283 public Asn1Tag getTag() { 284 return tag; 285 } 286 287 @Override 288 public boolean isImplicitTagging() { 289 return true; 290 } 291 292 @Override public String toIndentedString(String indent) { 293 return "radius_min : " 294 + getRadius_min().toIndentedString(indent); 295 } 296 }); 297 298 builder.add(new SequenceComponent() { 299 Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 3); 300 301 @Override public boolean isExplicitlySet() { 302 return getRadius_max() != null; 303 } 304 305 @Override public boolean hasDefaultValue() { 306 return false; 307 } 308 309 @Override public boolean isOptional() { 310 return true; 311 } 312 313 @Override public Asn1Object getComponentValue() { 314 return getRadius_max(); 315 } 316 317 @Override public void setToNewInstance() { 318 setRadius_maxToNewInstance(); 319 } 320 321 @Override public Collection<Asn1Tag> getPossibleFirstTags() { 322 return tag == null ? CircularArea.radius_maxType.getPossibleFirstTags() : ImmutableList.of(tag); 323 } 324 325 @Override 326 public Asn1Tag getTag() { 327 return tag; 328 } 329 330 @Override 331 public boolean isImplicitTagging() { 332 return true; 333 } 334 335 @Override public String toIndentedString(String indent) { 336 return "radius_max : " 337 + getRadius_max().toIndentedString(indent); 338 } 339 }); 340 341 return builder.build(); 342 } 343 344 @Override public Iterable<? extends SequenceComponent> 345 getExtensionComponents() { 346 ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder(); 347 348 return builder.build(); 349 } 350 351 352 353 354 /* 355 */ 356 357 358 // 359 360 /** 361 */ 362 public static class radiusType extends Asn1Integer { 363 // 364 365 private static final Asn1Tag TAG_radiusType 366 = Asn1Tag.fromClassAndNumber(-1, -1); 367 368 public radiusType() { 369 super(); 370 setValueRange("1", "1000000"); 371 372 } 373 374 @Override 375 @Nullable 376 protected Asn1Tag getTag() { 377 return TAG_radiusType; 378 } 379 380 @Override 381 protected boolean isTagImplicit() { 382 return true; 383 } 384 385 public static Collection<Asn1Tag> getPossibleFirstTags() { 386 if (TAG_radiusType != null) { 387 return ImmutableList.of(TAG_radiusType); 388 } else { 389 return Asn1Integer.getPossibleFirstTags(); 390 } 391 } 392 393 /** 394 * Creates a new radiusType from encoded stream. 395 */ 396 public static radiusType fromPerUnaligned(byte[] encodedBytes) { 397 radiusType result = new radiusType(); 398 result.decodePerUnaligned(new BitStreamReader(encodedBytes)); 399 return result; 400 } 401 402 /** 403 * Creates a new radiusType from encoded stream. 404 */ 405 public static radiusType fromPerAligned(byte[] encodedBytes) { 406 radiusType result = new radiusType(); 407 result.decodePerAligned(new BitStreamReader(encodedBytes)); 408 return result; 409 } 410 411 @Override public Iterable<BitStream> encodePerUnaligned() { 412 return super.encodePerUnaligned(); 413 } 414 415 @Override public Iterable<BitStream> encodePerAligned() { 416 return super.encodePerAligned(); 417 } 418 419 @Override public void decodePerUnaligned(BitStreamReader reader) { 420 super.decodePerUnaligned(reader); 421 } 422 423 @Override public void decodePerAligned(BitStreamReader reader) { 424 super.decodePerAligned(reader); 425 } 426 427 @Override public String toString() { 428 return toIndentedString(""); 429 } 430 431 public String toIndentedString(String indent) { 432 return "radiusType = " + getInteger() + ";\n"; 433 } 434 } 435 436 437 /* 438 */ 439 440 441 // 442 443 /** 444 */ 445 public static class radius_minType extends Asn1Integer { 446 // 447 448 private static final Asn1Tag TAG_radius_minType 449 = Asn1Tag.fromClassAndNumber(-1, -1); 450 451 public radius_minType() { 452 super(); 453 setValueRange("1", "1000000"); 454 455 } 456 457 @Override 458 @Nullable 459 protected Asn1Tag getTag() { 460 return TAG_radius_minType; 461 } 462 463 @Override 464 protected boolean isTagImplicit() { 465 return true; 466 } 467 468 public static Collection<Asn1Tag> getPossibleFirstTags() { 469 if (TAG_radius_minType != null) { 470 return ImmutableList.of(TAG_radius_minType); 471 } else { 472 return Asn1Integer.getPossibleFirstTags(); 473 } 474 } 475 476 /** 477 * Creates a new radius_minType from encoded stream. 478 */ 479 public static radius_minType fromPerUnaligned(byte[] encodedBytes) { 480 radius_minType result = new radius_minType(); 481 result.decodePerUnaligned(new BitStreamReader(encodedBytes)); 482 return result; 483 } 484 485 /** 486 * Creates a new radius_minType from encoded stream. 487 */ 488 public static radius_minType fromPerAligned(byte[] encodedBytes) { 489 radius_minType result = new radius_minType(); 490 result.decodePerAligned(new BitStreamReader(encodedBytes)); 491 return result; 492 } 493 494 @Override public Iterable<BitStream> encodePerUnaligned() { 495 return super.encodePerUnaligned(); 496 } 497 498 @Override public Iterable<BitStream> encodePerAligned() { 499 return super.encodePerAligned(); 500 } 501 502 @Override public void decodePerUnaligned(BitStreamReader reader) { 503 super.decodePerUnaligned(reader); 504 } 505 506 @Override public void decodePerAligned(BitStreamReader reader) { 507 super.decodePerAligned(reader); 508 } 509 510 @Override public String toString() { 511 return toIndentedString(""); 512 } 513 514 public String toIndentedString(String indent) { 515 return "radius_minType = " + getInteger() + ";\n"; 516 } 517 } 518 519 520 /* 521 */ 522 523 524 // 525 526 /** 527 */ 528 public static class radius_maxType extends Asn1Integer { 529 // 530 531 private static final Asn1Tag TAG_radius_maxType 532 = Asn1Tag.fromClassAndNumber(-1, -1); 533 534 public radius_maxType() { 535 super(); 536 setValueRange("1", "1500000"); 537 538 } 539 540 @Override 541 @Nullable 542 protected Asn1Tag getTag() { 543 return TAG_radius_maxType; 544 } 545 546 @Override 547 protected boolean isTagImplicit() { 548 return true; 549 } 550 551 public static Collection<Asn1Tag> getPossibleFirstTags() { 552 if (TAG_radius_maxType != null) { 553 return ImmutableList.of(TAG_radius_maxType); 554 } else { 555 return Asn1Integer.getPossibleFirstTags(); 556 } 557 } 558 559 /** 560 * Creates a new radius_maxType from encoded stream. 561 */ 562 public static radius_maxType fromPerUnaligned(byte[] encodedBytes) { 563 radius_maxType result = new radius_maxType(); 564 result.decodePerUnaligned(new BitStreamReader(encodedBytes)); 565 return result; 566 } 567 568 /** 569 * Creates a new radius_maxType from encoded stream. 570 */ 571 public static radius_maxType fromPerAligned(byte[] encodedBytes) { 572 radius_maxType result = new radius_maxType(); 573 result.decodePerAligned(new BitStreamReader(encodedBytes)); 574 return result; 575 } 576 577 @Override public Iterable<BitStream> encodePerUnaligned() { 578 return super.encodePerUnaligned(); 579 } 580 581 @Override public Iterable<BitStream> encodePerAligned() { 582 return super.encodePerAligned(); 583 } 584 585 @Override public void decodePerUnaligned(BitStreamReader reader) { 586 super.decodePerUnaligned(reader); 587 } 588 589 @Override public void decodePerAligned(BitStreamReader reader) { 590 super.decodePerAligned(reader); 591 } 592 593 @Override public String toString() { 594 return toIndentedString(""); 595 } 596 597 public String toIndentedString(String indent) { 598 return "radius_maxType = " + getInteger() + ";\n"; 599 } 600 } 601 602 603 604 605 606 @Override public Iterable<BitStream> encodePerUnaligned() { 607 return super.encodePerUnaligned(); 608 } 609 610 @Override public Iterable<BitStream> encodePerAligned() { 611 return super.encodePerAligned(); 612 } 613 614 @Override public void decodePerUnaligned(BitStreamReader reader) { 615 super.decodePerUnaligned(reader); 616 } 617 618 @Override public void decodePerAligned(BitStreamReader reader) { 619 super.decodePerAligned(reader); 620 } 621 622 @Override public String toString() { 623 return toIndentedString(""); 624 } 625 626 public String toIndentedString(String indent) { 627 StringBuilder builder = new StringBuilder(); 628 builder.append("CircularArea = {\n"); 629 final String internalIndent = indent + " "; 630 for (SequenceComponent component : getComponents()) { 631 if (component.isExplicitlySet()) { 632 builder.append(internalIndent) 633 .append(component.toIndentedString(internalIndent)); 634 } 635 } 636 if (isExtensible()) { 637 builder.append(internalIndent).append("...\n"); 638 for (SequenceComponent component : getExtensionComponents()) { 639 if (component.isExplicitlySet()) { 640 builder.append(internalIndent) 641 .append(component.toIndentedString(internalIndent)); 642 } 643 } 644 } 645 builder.append(indent).append("};\n"); 646 return builder.toString(); 647 } 648 } 649
