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.rrlp_components; 18 19 /* 20 */ 21 22 23 // 24 // 25 import android.location.cts.asn1.base.Asn1Null; 26 import android.location.cts.asn1.base.Asn1Object; 27 import android.location.cts.asn1.base.Asn1Sequence; 28 import android.location.cts.asn1.base.Asn1Tag; 29 import android.location.cts.asn1.base.BitStream; 30 import android.location.cts.asn1.base.BitStreamReader; 31 import android.location.cts.asn1.base.SequenceComponent; 32 import com.google.common.collect.ImmutableList; 33 import java.util.Collection; 34 import javax.annotation.Nullable; 35 36 37 /** 38 */ 39 public class GANSSTOD_GSMTimeAssociation extends Asn1Sequence { 40 // 41 42 private static final Asn1Tag TAG_GANSSTOD_GSMTimeAssociation 43 = Asn1Tag.fromClassAndNumber(-1, -1); 44 45 public GANSSTOD_GSMTimeAssociation() { 46 super(); 47 } 48 49 @Override 50 @Nullable 51 protected Asn1Tag getTag() { 52 return TAG_GANSSTOD_GSMTimeAssociation; 53 } 54 55 @Override 56 protected boolean isTagImplicit() { 57 return true; 58 } 59 60 public static Collection<Asn1Tag> getPossibleFirstTags() { 61 if (TAG_GANSSTOD_GSMTimeAssociation != null) { 62 return ImmutableList.of(TAG_GANSSTOD_GSMTimeAssociation); 63 } else { 64 return Asn1Sequence.getPossibleFirstTags(); 65 } 66 } 67 68 /** 69 * Creates a new GANSSTOD_GSMTimeAssociation from encoded stream. 70 */ 71 public static GANSSTOD_GSMTimeAssociation fromPerUnaligned(byte[] encodedBytes) { 72 GANSSTOD_GSMTimeAssociation result = new GANSSTOD_GSMTimeAssociation(); 73 result.decodePerUnaligned(new BitStreamReader(encodedBytes)); 74 return result; 75 } 76 77 /** 78 * Creates a new GANSSTOD_GSMTimeAssociation from encoded stream. 79 */ 80 public static GANSSTOD_GSMTimeAssociation fromPerAligned(byte[] encodedBytes) { 81 GANSSTOD_GSMTimeAssociation result = new GANSSTOD_GSMTimeAssociation(); 82 result.decodePerAligned(new BitStreamReader(encodedBytes)); 83 return result; 84 } 85 86 87 88 @Override protected boolean isExtensible() { 89 return false; 90 } 91 92 @Override public boolean containsExtensionValues() { 93 for (SequenceComponent extensionComponent : getExtensionComponents()) { 94 if (extensionComponent.isExplicitlySet()) return true; 95 } 96 return false; 97 } 98 99 100 private BCCHCarrier bcchCarrier_; 101 public BCCHCarrier getBcchCarrier() { 102 return bcchCarrier_; 103 } 104 /** 105 * @throws ClassCastException if value is not a BCCHCarrier 106 */ 107 public void setBcchCarrier(Asn1Object value) { 108 this.bcchCarrier_ = (BCCHCarrier) value; 109 } 110 public BCCHCarrier setBcchCarrierToNewInstance() { 111 bcchCarrier_ = new BCCHCarrier(); 112 return bcchCarrier_; 113 } 114 115 private BSIC bsic_; 116 public BSIC getBsic() { 117 return bsic_; 118 } 119 /** 120 * @throws ClassCastException if value is not a BSIC 121 */ 122 public void setBsic(Asn1Object value) { 123 this.bsic_ = (BSIC) value; 124 } 125 public BSIC setBsicToNewInstance() { 126 bsic_ = new BSIC(); 127 return bsic_; 128 } 129 130 private FrameNumber frameNumber_; 131 public FrameNumber getFrameNumber() { 132 return frameNumber_; 133 } 134 /** 135 * @throws ClassCastException if value is not a FrameNumber 136 */ 137 public void setFrameNumber(Asn1Object value) { 138 this.frameNumber_ = (FrameNumber) value; 139 } 140 public FrameNumber setFrameNumberToNewInstance() { 141 frameNumber_ = new FrameNumber(); 142 return frameNumber_; 143 } 144 145 private TimeSlot timeSlot_; 146 public TimeSlot getTimeSlot() { 147 return timeSlot_; 148 } 149 /** 150 * @throws ClassCastException if value is not a TimeSlot 151 */ 152 public void setTimeSlot(Asn1Object value) { 153 this.timeSlot_ = (TimeSlot) value; 154 } 155 public TimeSlot setTimeSlotToNewInstance() { 156 timeSlot_ = new TimeSlot(); 157 return timeSlot_; 158 } 159 160 private BitNumber bitNumber_; 161 public BitNumber getBitNumber() { 162 return bitNumber_; 163 } 164 /** 165 * @throws ClassCastException if value is not a BitNumber 166 */ 167 public void setBitNumber(Asn1Object value) { 168 this.bitNumber_ = (BitNumber) value; 169 } 170 public BitNumber setBitNumberToNewInstance() { 171 bitNumber_ = new BitNumber(); 172 return bitNumber_; 173 } 174 175 private FrameDrift frameDrift_; 176 public FrameDrift getFrameDrift() { 177 return frameDrift_; 178 } 179 /** 180 * @throws ClassCastException if value is not a FrameDrift 181 */ 182 public void setFrameDrift(Asn1Object value) { 183 this.frameDrift_ = (FrameDrift) value; 184 } 185 public FrameDrift setFrameDriftToNewInstance() { 186 frameDrift_ = new FrameDrift(); 187 return frameDrift_; 188 } 189 190 191 192 193 194 195 @Override public Iterable<? extends SequenceComponent> getComponents() { 196 ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder(); 197 198 builder.add(new SequenceComponent() { 199 Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0); 200 201 @Override public boolean isExplicitlySet() { 202 return getBcchCarrier() != null; 203 } 204 205 @Override public boolean hasDefaultValue() { 206 return false; 207 } 208 209 @Override public boolean isOptional() { 210 return false; 211 } 212 213 @Override public Asn1Object getComponentValue() { 214 return getBcchCarrier(); 215 } 216 217 @Override public void setToNewInstance() { 218 setBcchCarrierToNewInstance(); 219 } 220 221 @Override public Collection<Asn1Tag> getPossibleFirstTags() { 222 return tag == null ? BCCHCarrier.getPossibleFirstTags() : ImmutableList.of(tag); 223 } 224 225 @Override 226 public Asn1Tag getTag() { 227 return tag; 228 } 229 230 @Override 231 public boolean isImplicitTagging() { 232 return true; 233 } 234 235 @Override public String toIndentedString(String indent) { 236 return "bcchCarrier : " 237 + getBcchCarrier().toIndentedString(indent); 238 } 239 }); 240 241 builder.add(new SequenceComponent() { 242 Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1); 243 244 @Override public boolean isExplicitlySet() { 245 return getBsic() != null; 246 } 247 248 @Override public boolean hasDefaultValue() { 249 return false; 250 } 251 252 @Override public boolean isOptional() { 253 return false; 254 } 255 256 @Override public Asn1Object getComponentValue() { 257 return getBsic(); 258 } 259 260 @Override public void setToNewInstance() { 261 setBsicToNewInstance(); 262 } 263 264 @Override public Collection<Asn1Tag> getPossibleFirstTags() { 265 return tag == null ? BSIC.getPossibleFirstTags() : ImmutableList.of(tag); 266 } 267 268 @Override 269 public Asn1Tag getTag() { 270 return tag; 271 } 272 273 @Override 274 public boolean isImplicitTagging() { 275 return true; 276 } 277 278 @Override public String toIndentedString(String indent) { 279 return "bsic : " 280 + getBsic().toIndentedString(indent); 281 } 282 }); 283 284 builder.add(new SequenceComponent() { 285 Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2); 286 287 @Override public boolean isExplicitlySet() { 288 return getFrameNumber() != null; 289 } 290 291 @Override public boolean hasDefaultValue() { 292 return false; 293 } 294 295 @Override public boolean isOptional() { 296 return false; 297 } 298 299 @Override public Asn1Object getComponentValue() { 300 return getFrameNumber(); 301 } 302 303 @Override public void setToNewInstance() { 304 setFrameNumberToNewInstance(); 305 } 306 307 @Override public Collection<Asn1Tag> getPossibleFirstTags() { 308 return tag == null ? FrameNumber.getPossibleFirstTags() : ImmutableList.of(tag); 309 } 310 311 @Override 312 public Asn1Tag getTag() { 313 return tag; 314 } 315 316 @Override 317 public boolean isImplicitTagging() { 318 return true; 319 } 320 321 @Override public String toIndentedString(String indent) { 322 return "frameNumber : " 323 + getFrameNumber().toIndentedString(indent); 324 } 325 }); 326 327 builder.add(new SequenceComponent() { 328 Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 3); 329 330 @Override public boolean isExplicitlySet() { 331 return getTimeSlot() != null; 332 } 333 334 @Override public boolean hasDefaultValue() { 335 return false; 336 } 337 338 @Override public boolean isOptional() { 339 return false; 340 } 341 342 @Override public Asn1Object getComponentValue() { 343 return getTimeSlot(); 344 } 345 346 @Override public void setToNewInstance() { 347 setTimeSlotToNewInstance(); 348 } 349 350 @Override public Collection<Asn1Tag> getPossibleFirstTags() { 351 return tag == null ? TimeSlot.getPossibleFirstTags() : ImmutableList.of(tag); 352 } 353 354 @Override 355 public Asn1Tag getTag() { 356 return tag; 357 } 358 359 @Override 360 public boolean isImplicitTagging() { 361 return true; 362 } 363 364 @Override public String toIndentedString(String indent) { 365 return "timeSlot : " 366 + getTimeSlot().toIndentedString(indent); 367 } 368 }); 369 370 builder.add(new SequenceComponent() { 371 Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 4); 372 373 @Override public boolean isExplicitlySet() { 374 return getBitNumber() != null; 375 } 376 377 @Override public boolean hasDefaultValue() { 378 return false; 379 } 380 381 @Override public boolean isOptional() { 382 return false; 383 } 384 385 @Override public Asn1Object getComponentValue() { 386 return getBitNumber(); 387 } 388 389 @Override public void setToNewInstance() { 390 setBitNumberToNewInstance(); 391 } 392 393 @Override public Collection<Asn1Tag> getPossibleFirstTags() { 394 return tag == null ? BitNumber.getPossibleFirstTags() : ImmutableList.of(tag); 395 } 396 397 @Override 398 public Asn1Tag getTag() { 399 return tag; 400 } 401 402 @Override 403 public boolean isImplicitTagging() { 404 return true; 405 } 406 407 @Override public String toIndentedString(String indent) { 408 return "bitNumber : " 409 + getBitNumber().toIndentedString(indent); 410 } 411 }); 412 413 builder.add(new SequenceComponent() { 414 Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 5); 415 416 @Override public boolean isExplicitlySet() { 417 return getFrameDrift() != null; 418 } 419 420 @Override public boolean hasDefaultValue() { 421 return false; 422 } 423 424 @Override public boolean isOptional() { 425 return true; 426 } 427 428 @Override public Asn1Object getComponentValue() { 429 return getFrameDrift(); 430 } 431 432 @Override public void setToNewInstance() { 433 setFrameDriftToNewInstance(); 434 } 435 436 @Override public Collection<Asn1Tag> getPossibleFirstTags() { 437 return tag == null ? FrameDrift.getPossibleFirstTags() : ImmutableList.of(tag); 438 } 439 440 @Override 441 public Asn1Tag getTag() { 442 return tag; 443 } 444 445 @Override 446 public boolean isImplicitTagging() { 447 return true; 448 } 449 450 @Override public String toIndentedString(String indent) { 451 return "frameDrift : " 452 + getFrameDrift().toIndentedString(indent); 453 } 454 }); 455 456 return builder.build(); 457 } 458 459 @Override public Iterable<? extends SequenceComponent> 460 getExtensionComponents() { 461 ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder(); 462 463 return builder.build(); 464 } 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 @Override public Iterable<BitStream> encodePerUnaligned() { 483 return super.encodePerUnaligned(); 484 } 485 486 @Override public Iterable<BitStream> encodePerAligned() { 487 return super.encodePerAligned(); 488 } 489 490 @Override public void decodePerUnaligned(BitStreamReader reader) { 491 super.decodePerUnaligned(reader); 492 } 493 494 @Override public void decodePerAligned(BitStreamReader reader) { 495 super.decodePerAligned(reader); 496 } 497 498 @Override public String toString() { 499 return toIndentedString(""); 500 } 501 502 public String toIndentedString(String indent) { 503 StringBuilder builder = new StringBuilder(); 504 builder.append("GANSSTOD_GSMTimeAssociation = {\n"); 505 final String internalIndent = indent + " "; 506 for (SequenceComponent component : getComponents()) { 507 if (component.isExplicitlySet()) { 508 builder.append(internalIndent) 509 .append(component.toIndentedString(internalIndent)); 510 } 511 } 512 if (isExtensible()) { 513 builder.append(internalIndent).append("...\n"); 514 for (SequenceComponent component : getExtensionComponents()) { 515 if (component.isExplicitlySet()) { 516 builder.append(internalIndent) 517 .append(component.toIndentedString(internalIndent)); 518 } 519 } 520 } 521 builder.append(indent).append("};\n"); 522 return builder.toString(); 523 } 524 } 525