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.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 AcquisElement extends Asn1Sequence {
41   //
42 
43   private static final Asn1Tag TAG_AcquisElement
44       = Asn1Tag.fromClassAndNumber(-1, -1);
45 
AcquisElement()46   public AcquisElement() {
47     super();
48   }
49 
50   @Override
51   @Nullable
getTag()52   protected Asn1Tag getTag() {
53     return TAG_AcquisElement;
54   }
55 
56   @Override
isTagImplicit()57   protected boolean isTagImplicit() {
58     return true;
59   }
60 
getPossibleFirstTags()61   public static Collection<Asn1Tag> getPossibleFirstTags() {
62     if (TAG_AcquisElement != null) {
63       return ImmutableList.of(TAG_AcquisElement);
64     } else {
65       return Asn1Sequence.getPossibleFirstTags();
66     }
67   }
68 
69   /**
70    * Creates a new AcquisElement from encoded stream.
71    */
fromPerUnaligned(byte[] encodedBytes)72   public static AcquisElement fromPerUnaligned(byte[] encodedBytes) {
73     AcquisElement result = new AcquisElement();
74     result.decodePerUnaligned(new BitStreamReader(encodedBytes));
75     return result;
76   }
77 
78   /**
79    * Creates a new AcquisElement from encoded stream.
80    */
fromPerAligned(byte[] encodedBytes)81   public static AcquisElement fromPerAligned(byte[] encodedBytes) {
82     AcquisElement result = new AcquisElement();
83     result.decodePerAligned(new BitStreamReader(encodedBytes));
84     return result;
85   }
86 
87 
88 
isExtensible()89   @Override protected boolean isExtensible() {
90     return false;
91   }
92 
containsExtensionValues()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 SatelliteID svid_;
getSvid()102   public SatelliteID getSvid() {
103     return svid_;
104   }
105   /**
106    * @throws ClassCastException if value is not a SatelliteID
107    */
setSvid(Asn1Object value)108   public void setSvid(Asn1Object value) {
109     this.svid_ = (SatelliteID) value;
110   }
setSvidToNewInstance()111   public SatelliteID setSvidToNewInstance() {
112     svid_ = new SatelliteID();
113     return svid_;
114   }
115 
116   private AcquisElement.doppler0Type doppler0_;
getDoppler0()117   public AcquisElement.doppler0Type getDoppler0() {
118     return doppler0_;
119   }
120   /**
121    * @throws ClassCastException if value is not a AcquisElement.doppler0Type
122    */
setDoppler0(Asn1Object value)123   public void setDoppler0(Asn1Object value) {
124     this.doppler0_ = (AcquisElement.doppler0Type) value;
125   }
setDoppler0ToNewInstance()126   public AcquisElement.doppler0Type setDoppler0ToNewInstance() {
127     doppler0_ = new AcquisElement.doppler0Type();
128     return doppler0_;
129   }
130 
131   private AddionalDopplerFields addionalDoppler_;
getAddionalDoppler()132   public AddionalDopplerFields getAddionalDoppler() {
133     return addionalDoppler_;
134   }
135   /**
136    * @throws ClassCastException if value is not a AddionalDopplerFields
137    */
setAddionalDoppler(Asn1Object value)138   public void setAddionalDoppler(Asn1Object value) {
139     this.addionalDoppler_ = (AddionalDopplerFields) value;
140   }
setAddionalDopplerToNewInstance()141   public AddionalDopplerFields setAddionalDopplerToNewInstance() {
142     addionalDoppler_ = new AddionalDopplerFields();
143     return addionalDoppler_;
144   }
145 
146   private AcquisElement.codePhaseType codePhase_;
getCodePhase()147   public AcquisElement.codePhaseType getCodePhase() {
148     return codePhase_;
149   }
150   /**
151    * @throws ClassCastException if value is not a AcquisElement.codePhaseType
152    */
setCodePhase(Asn1Object value)153   public void setCodePhase(Asn1Object value) {
154     this.codePhase_ = (AcquisElement.codePhaseType) value;
155   }
setCodePhaseToNewInstance()156   public AcquisElement.codePhaseType setCodePhaseToNewInstance() {
157     codePhase_ = new AcquisElement.codePhaseType();
158     return codePhase_;
159   }
160 
161   private AcquisElement.intCodePhaseType intCodePhase_;
getIntCodePhase()162   public AcquisElement.intCodePhaseType getIntCodePhase() {
163     return intCodePhase_;
164   }
165   /**
166    * @throws ClassCastException if value is not a AcquisElement.intCodePhaseType
167    */
setIntCodePhase(Asn1Object value)168   public void setIntCodePhase(Asn1Object value) {
169     this.intCodePhase_ = (AcquisElement.intCodePhaseType) value;
170   }
setIntCodePhaseToNewInstance()171   public AcquisElement.intCodePhaseType setIntCodePhaseToNewInstance() {
172     intCodePhase_ = new AcquisElement.intCodePhaseType();
173     return intCodePhase_;
174   }
175 
176   private AcquisElement.gpsBitNumberType gpsBitNumber_;
getGpsBitNumber()177   public AcquisElement.gpsBitNumberType getGpsBitNumber() {
178     return gpsBitNumber_;
179   }
180   /**
181    * @throws ClassCastException if value is not a AcquisElement.gpsBitNumberType
182    */
setGpsBitNumber(Asn1Object value)183   public void setGpsBitNumber(Asn1Object value) {
184     this.gpsBitNumber_ = (AcquisElement.gpsBitNumberType) value;
185   }
setGpsBitNumberToNewInstance()186   public AcquisElement.gpsBitNumberType setGpsBitNumberToNewInstance() {
187     gpsBitNumber_ = new AcquisElement.gpsBitNumberType();
188     return gpsBitNumber_;
189   }
190 
191   private AcquisElement.codePhaseSearchWindowType codePhaseSearchWindow_;
getCodePhaseSearchWindow()192   public AcquisElement.codePhaseSearchWindowType getCodePhaseSearchWindow() {
193     return codePhaseSearchWindow_;
194   }
195   /**
196    * @throws ClassCastException if value is not a AcquisElement.codePhaseSearchWindowType
197    */
setCodePhaseSearchWindow(Asn1Object value)198   public void setCodePhaseSearchWindow(Asn1Object value) {
199     this.codePhaseSearchWindow_ = (AcquisElement.codePhaseSearchWindowType) value;
200   }
setCodePhaseSearchWindowToNewInstance()201   public AcquisElement.codePhaseSearchWindowType setCodePhaseSearchWindowToNewInstance() {
202     codePhaseSearchWindow_ = new AcquisElement.codePhaseSearchWindowType();
203     return codePhaseSearchWindow_;
204   }
205 
206   private AddionalAngleFields addionalAngle_;
getAddionalAngle()207   public AddionalAngleFields getAddionalAngle() {
208     return addionalAngle_;
209   }
210   /**
211    * @throws ClassCastException if value is not a AddionalAngleFields
212    */
setAddionalAngle(Asn1Object value)213   public void setAddionalAngle(Asn1Object value) {
214     this.addionalAngle_ = (AddionalAngleFields) value;
215   }
setAddionalAngleToNewInstance()216   public AddionalAngleFields setAddionalAngleToNewInstance() {
217     addionalAngle_ = new AddionalAngleFields();
218     return addionalAngle_;
219   }
220 
221 
222 
223 
224 
225 
getComponents()226   @Override public Iterable<? extends SequenceComponent> getComponents() {
227     ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
228 
229     builder.add(new SequenceComponent() {
230           Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
231 
232           @Override public boolean isExplicitlySet() {
233             return getSvid() != null;
234           }
235 
236           @Override public boolean hasDefaultValue() {
237             return false;
238           }
239 
240           @Override public boolean isOptional() {
241             return false;
242           }
243 
244           @Override public Asn1Object getComponentValue() {
245             return getSvid();
246           }
247 
248           @Override public void setToNewInstance() {
249             setSvidToNewInstance();
250           }
251 
252           @Override public Collection<Asn1Tag> getPossibleFirstTags() {
253             return tag == null ? SatelliteID.getPossibleFirstTags() : ImmutableList.of(tag);
254           }
255 
256           @Override
257           public Asn1Tag getTag() {
258             return tag;
259           }
260 
261           @Override
262           public boolean isImplicitTagging() {
263             return true;
264           }
265 
266           @Override public String toIndentedString(String indent) {
267                 return "svid : "
268                     + getSvid().toIndentedString(indent);
269               }
270         });
271 
272     builder.add(new SequenceComponent() {
273           Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
274 
275           @Override public boolean isExplicitlySet() {
276             return getDoppler0() != null;
277           }
278 
279           @Override public boolean hasDefaultValue() {
280             return false;
281           }
282 
283           @Override public boolean isOptional() {
284             return false;
285           }
286 
287           @Override public Asn1Object getComponentValue() {
288             return getDoppler0();
289           }
290 
291           @Override public void setToNewInstance() {
292             setDoppler0ToNewInstance();
293           }
294 
295           @Override public Collection<Asn1Tag> getPossibleFirstTags() {
296             return tag == null ? AcquisElement.doppler0Type.getPossibleFirstTags() : ImmutableList.of(tag);
297           }
298 
299           @Override
300           public Asn1Tag getTag() {
301             return tag;
302           }
303 
304           @Override
305           public boolean isImplicitTagging() {
306             return true;
307           }
308 
309           @Override public String toIndentedString(String indent) {
310                 return "doppler0 : "
311                     + getDoppler0().toIndentedString(indent);
312               }
313         });
314 
315     builder.add(new SequenceComponent() {
316           Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
317 
318           @Override public boolean isExplicitlySet() {
319             return getAddionalDoppler() != null;
320           }
321 
322           @Override public boolean hasDefaultValue() {
323             return false;
324           }
325 
326           @Override public boolean isOptional() {
327             return true;
328           }
329 
330           @Override public Asn1Object getComponentValue() {
331             return getAddionalDoppler();
332           }
333 
334           @Override public void setToNewInstance() {
335             setAddionalDopplerToNewInstance();
336           }
337 
338           @Override public Collection<Asn1Tag> getPossibleFirstTags() {
339             return tag == null ? AddionalDopplerFields.getPossibleFirstTags() : ImmutableList.of(tag);
340           }
341 
342           @Override
343           public Asn1Tag getTag() {
344             return tag;
345           }
346 
347           @Override
348           public boolean isImplicitTagging() {
349             return true;
350           }
351 
352           @Override public String toIndentedString(String indent) {
353                 return "addionalDoppler : "
354                     + getAddionalDoppler().toIndentedString(indent);
355               }
356         });
357 
358     builder.add(new SequenceComponent() {
359           Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 3);
360 
361           @Override public boolean isExplicitlySet() {
362             return getCodePhase() != null;
363           }
364 
365           @Override public boolean hasDefaultValue() {
366             return false;
367           }
368 
369           @Override public boolean isOptional() {
370             return false;
371           }
372 
373           @Override public Asn1Object getComponentValue() {
374             return getCodePhase();
375           }
376 
377           @Override public void setToNewInstance() {
378             setCodePhaseToNewInstance();
379           }
380 
381           @Override public Collection<Asn1Tag> getPossibleFirstTags() {
382             return tag == null ? AcquisElement.codePhaseType.getPossibleFirstTags() : ImmutableList.of(tag);
383           }
384 
385           @Override
386           public Asn1Tag getTag() {
387             return tag;
388           }
389 
390           @Override
391           public boolean isImplicitTagging() {
392             return true;
393           }
394 
395           @Override public String toIndentedString(String indent) {
396                 return "codePhase : "
397                     + getCodePhase().toIndentedString(indent);
398               }
399         });
400 
401     builder.add(new SequenceComponent() {
402           Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 4);
403 
404           @Override public boolean isExplicitlySet() {
405             return getIntCodePhase() != null;
406           }
407 
408           @Override public boolean hasDefaultValue() {
409             return false;
410           }
411 
412           @Override public boolean isOptional() {
413             return false;
414           }
415 
416           @Override public Asn1Object getComponentValue() {
417             return getIntCodePhase();
418           }
419 
420           @Override public void setToNewInstance() {
421             setIntCodePhaseToNewInstance();
422           }
423 
424           @Override public Collection<Asn1Tag> getPossibleFirstTags() {
425             return tag == null ? AcquisElement.intCodePhaseType.getPossibleFirstTags() : ImmutableList.of(tag);
426           }
427 
428           @Override
429           public Asn1Tag getTag() {
430             return tag;
431           }
432 
433           @Override
434           public boolean isImplicitTagging() {
435             return true;
436           }
437 
438           @Override public String toIndentedString(String indent) {
439                 return "intCodePhase : "
440                     + getIntCodePhase().toIndentedString(indent);
441               }
442         });
443 
444     builder.add(new SequenceComponent() {
445           Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 5);
446 
447           @Override public boolean isExplicitlySet() {
448             return getGpsBitNumber() != null;
449           }
450 
451           @Override public boolean hasDefaultValue() {
452             return false;
453           }
454 
455           @Override public boolean isOptional() {
456             return false;
457           }
458 
459           @Override public Asn1Object getComponentValue() {
460             return getGpsBitNumber();
461           }
462 
463           @Override public void setToNewInstance() {
464             setGpsBitNumberToNewInstance();
465           }
466 
467           @Override public Collection<Asn1Tag> getPossibleFirstTags() {
468             return tag == null ? AcquisElement.gpsBitNumberType.getPossibleFirstTags() : ImmutableList.of(tag);
469           }
470 
471           @Override
472           public Asn1Tag getTag() {
473             return tag;
474           }
475 
476           @Override
477           public boolean isImplicitTagging() {
478             return true;
479           }
480 
481           @Override public String toIndentedString(String indent) {
482                 return "gpsBitNumber : "
483                     + getGpsBitNumber().toIndentedString(indent);
484               }
485         });
486 
487     builder.add(new SequenceComponent() {
488           Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 6);
489 
490           @Override public boolean isExplicitlySet() {
491             return getCodePhaseSearchWindow() != null;
492           }
493 
494           @Override public boolean hasDefaultValue() {
495             return false;
496           }
497 
498           @Override public boolean isOptional() {
499             return false;
500           }
501 
502           @Override public Asn1Object getComponentValue() {
503             return getCodePhaseSearchWindow();
504           }
505 
506           @Override public void setToNewInstance() {
507             setCodePhaseSearchWindowToNewInstance();
508           }
509 
510           @Override public Collection<Asn1Tag> getPossibleFirstTags() {
511             return tag == null ? AcquisElement.codePhaseSearchWindowType.getPossibleFirstTags() : ImmutableList.of(tag);
512           }
513 
514           @Override
515           public Asn1Tag getTag() {
516             return tag;
517           }
518 
519           @Override
520           public boolean isImplicitTagging() {
521             return true;
522           }
523 
524           @Override public String toIndentedString(String indent) {
525                 return "codePhaseSearchWindow : "
526                     + getCodePhaseSearchWindow().toIndentedString(indent);
527               }
528         });
529 
530     builder.add(new SequenceComponent() {
531           Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 7);
532 
533           @Override public boolean isExplicitlySet() {
534             return getAddionalAngle() != null;
535           }
536 
537           @Override public boolean hasDefaultValue() {
538             return false;
539           }
540 
541           @Override public boolean isOptional() {
542             return true;
543           }
544 
545           @Override public Asn1Object getComponentValue() {
546             return getAddionalAngle();
547           }
548 
549           @Override public void setToNewInstance() {
550             setAddionalAngleToNewInstance();
551           }
552 
553           @Override public Collection<Asn1Tag> getPossibleFirstTags() {
554             return tag == null ? AddionalAngleFields.getPossibleFirstTags() : ImmutableList.of(tag);
555           }
556 
557           @Override
558           public Asn1Tag getTag() {
559             return tag;
560           }
561 
562           @Override
563           public boolean isImplicitTagging() {
564             return true;
565           }
566 
567           @Override public String toIndentedString(String indent) {
568                 return "addionalAngle : "
569                     + getAddionalAngle().toIndentedString(indent);
570               }
571         });
572 
573     return builder.build();
574   }
575 
576   @Override public Iterable<? extends SequenceComponent>
getExtensionComponents()577                                                     getExtensionComponents() {
578     ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
579 
580       return builder.build();
581     }
582 
583 
584 
585 
586 /*
587  */
588 
589 
590 //
591 
592 /**
593  */
594 public static class doppler0Type extends Asn1Integer {
595   //
596 
597   private static final Asn1Tag TAG_doppler0Type
598       = Asn1Tag.fromClassAndNumber(-1, -1);
599 
doppler0Type()600   public doppler0Type() {
601     super();
602     setValueRange("-2048", "2047");
603 
604   }
605 
606   @Override
607   @Nullable
getTag()608   protected Asn1Tag getTag() {
609     return TAG_doppler0Type;
610   }
611 
612   @Override
isTagImplicit()613   protected boolean isTagImplicit() {
614     return true;
615   }
616 
getPossibleFirstTags()617   public static Collection<Asn1Tag> getPossibleFirstTags() {
618     if (TAG_doppler0Type != null) {
619       return ImmutableList.of(TAG_doppler0Type);
620     } else {
621       return Asn1Integer.getPossibleFirstTags();
622     }
623   }
624 
625   /**
626    * Creates a new doppler0Type from encoded stream.
627    */
fromPerUnaligned(byte[] encodedBytes)628   public static doppler0Type fromPerUnaligned(byte[] encodedBytes) {
629     doppler0Type result = new doppler0Type();
630     result.decodePerUnaligned(new BitStreamReader(encodedBytes));
631     return result;
632   }
633 
634   /**
635    * Creates a new doppler0Type from encoded stream.
636    */
fromPerAligned(byte[] encodedBytes)637   public static doppler0Type fromPerAligned(byte[] encodedBytes) {
638     doppler0Type result = new doppler0Type();
639     result.decodePerAligned(new BitStreamReader(encodedBytes));
640     return result;
641   }
642 
encodePerUnaligned()643   @Override public Iterable<BitStream> encodePerUnaligned() {
644     return super.encodePerUnaligned();
645   }
646 
encodePerAligned()647   @Override public Iterable<BitStream> encodePerAligned() {
648     return super.encodePerAligned();
649   }
650 
decodePerUnaligned(BitStreamReader reader)651   @Override public void decodePerUnaligned(BitStreamReader reader) {
652     super.decodePerUnaligned(reader);
653   }
654 
decodePerAligned(BitStreamReader reader)655   @Override public void decodePerAligned(BitStreamReader reader) {
656     super.decodePerAligned(reader);
657   }
658 
toString()659   @Override public String toString() {
660     return toIndentedString("");
661   }
662 
toIndentedString(String indent)663   public String toIndentedString(String indent) {
664     return "doppler0Type = " + getInteger() + ";\n";
665   }
666 }
667 
668 
669 
670 
671 /*
672  */
673 
674 
675 //
676 
677 /**
678  */
679 public static class codePhaseType extends Asn1Integer {
680   //
681 
682   private static final Asn1Tag TAG_codePhaseType
683       = Asn1Tag.fromClassAndNumber(-1, -1);
684 
codePhaseType()685   public codePhaseType() {
686     super();
687     setValueRange("0", "1022");
688 
689   }
690 
691   @Override
692   @Nullable
getTag()693   protected Asn1Tag getTag() {
694     return TAG_codePhaseType;
695   }
696 
697   @Override
isTagImplicit()698   protected boolean isTagImplicit() {
699     return true;
700   }
701 
getPossibleFirstTags()702   public static Collection<Asn1Tag> getPossibleFirstTags() {
703     if (TAG_codePhaseType != null) {
704       return ImmutableList.of(TAG_codePhaseType);
705     } else {
706       return Asn1Integer.getPossibleFirstTags();
707     }
708   }
709 
710   /**
711    * Creates a new codePhaseType from encoded stream.
712    */
fromPerUnaligned(byte[] encodedBytes)713   public static codePhaseType fromPerUnaligned(byte[] encodedBytes) {
714     codePhaseType result = new codePhaseType();
715     result.decodePerUnaligned(new BitStreamReader(encodedBytes));
716     return result;
717   }
718 
719   /**
720    * Creates a new codePhaseType from encoded stream.
721    */
fromPerAligned(byte[] encodedBytes)722   public static codePhaseType fromPerAligned(byte[] encodedBytes) {
723     codePhaseType result = new codePhaseType();
724     result.decodePerAligned(new BitStreamReader(encodedBytes));
725     return result;
726   }
727 
encodePerUnaligned()728   @Override public Iterable<BitStream> encodePerUnaligned() {
729     return super.encodePerUnaligned();
730   }
731 
encodePerAligned()732   @Override public Iterable<BitStream> encodePerAligned() {
733     return super.encodePerAligned();
734   }
735 
decodePerUnaligned(BitStreamReader reader)736   @Override public void decodePerUnaligned(BitStreamReader reader) {
737     super.decodePerUnaligned(reader);
738   }
739 
decodePerAligned(BitStreamReader reader)740   @Override public void decodePerAligned(BitStreamReader reader) {
741     super.decodePerAligned(reader);
742   }
743 
toString()744   @Override public String toString() {
745     return toIndentedString("");
746   }
747 
toIndentedString(String indent)748   public String toIndentedString(String indent) {
749     return "codePhaseType = " + getInteger() + ";\n";
750   }
751 }
752 
753 
754 /*
755  */
756 
757 
758 //
759 
760 /**
761  */
762 public static class intCodePhaseType extends Asn1Integer {
763   //
764 
765   private static final Asn1Tag TAG_intCodePhaseType
766       = Asn1Tag.fromClassAndNumber(-1, -1);
767 
intCodePhaseType()768   public intCodePhaseType() {
769     super();
770     setValueRange("0", "19");
771 
772   }
773 
774   @Override
775   @Nullable
getTag()776   protected Asn1Tag getTag() {
777     return TAG_intCodePhaseType;
778   }
779 
780   @Override
isTagImplicit()781   protected boolean isTagImplicit() {
782     return true;
783   }
784 
getPossibleFirstTags()785   public static Collection<Asn1Tag> getPossibleFirstTags() {
786     if (TAG_intCodePhaseType != null) {
787       return ImmutableList.of(TAG_intCodePhaseType);
788     } else {
789       return Asn1Integer.getPossibleFirstTags();
790     }
791   }
792 
793   /**
794    * Creates a new intCodePhaseType from encoded stream.
795    */
fromPerUnaligned(byte[] encodedBytes)796   public static intCodePhaseType fromPerUnaligned(byte[] encodedBytes) {
797     intCodePhaseType result = new intCodePhaseType();
798     result.decodePerUnaligned(new BitStreamReader(encodedBytes));
799     return result;
800   }
801 
802   /**
803    * Creates a new intCodePhaseType from encoded stream.
804    */
fromPerAligned(byte[] encodedBytes)805   public static intCodePhaseType fromPerAligned(byte[] encodedBytes) {
806     intCodePhaseType result = new intCodePhaseType();
807     result.decodePerAligned(new BitStreamReader(encodedBytes));
808     return result;
809   }
810 
encodePerUnaligned()811   @Override public Iterable<BitStream> encodePerUnaligned() {
812     return super.encodePerUnaligned();
813   }
814 
encodePerAligned()815   @Override public Iterable<BitStream> encodePerAligned() {
816     return super.encodePerAligned();
817   }
818 
decodePerUnaligned(BitStreamReader reader)819   @Override public void decodePerUnaligned(BitStreamReader reader) {
820     super.decodePerUnaligned(reader);
821   }
822 
decodePerAligned(BitStreamReader reader)823   @Override public void decodePerAligned(BitStreamReader reader) {
824     super.decodePerAligned(reader);
825   }
826 
toString()827   @Override public String toString() {
828     return toIndentedString("");
829   }
830 
toIndentedString(String indent)831   public String toIndentedString(String indent) {
832     return "intCodePhaseType = " + getInteger() + ";\n";
833   }
834 }
835 
836 
837 /*
838  */
839 
840 
841 //
842 
843 /**
844  */
845 public static class gpsBitNumberType extends Asn1Integer {
846   //
847 
848   private static final Asn1Tag TAG_gpsBitNumberType
849       = Asn1Tag.fromClassAndNumber(-1, -1);
850 
gpsBitNumberType()851   public gpsBitNumberType() {
852     super();
853     setValueRange("0", "3");
854 
855   }
856 
857   @Override
858   @Nullable
getTag()859   protected Asn1Tag getTag() {
860     return TAG_gpsBitNumberType;
861   }
862 
863   @Override
isTagImplicit()864   protected boolean isTagImplicit() {
865     return true;
866   }
867 
getPossibleFirstTags()868   public static Collection<Asn1Tag> getPossibleFirstTags() {
869     if (TAG_gpsBitNumberType != null) {
870       return ImmutableList.of(TAG_gpsBitNumberType);
871     } else {
872       return Asn1Integer.getPossibleFirstTags();
873     }
874   }
875 
876   /**
877    * Creates a new gpsBitNumberType from encoded stream.
878    */
fromPerUnaligned(byte[] encodedBytes)879   public static gpsBitNumberType fromPerUnaligned(byte[] encodedBytes) {
880     gpsBitNumberType result = new gpsBitNumberType();
881     result.decodePerUnaligned(new BitStreamReader(encodedBytes));
882     return result;
883   }
884 
885   /**
886    * Creates a new gpsBitNumberType from encoded stream.
887    */
fromPerAligned(byte[] encodedBytes)888   public static gpsBitNumberType fromPerAligned(byte[] encodedBytes) {
889     gpsBitNumberType result = new gpsBitNumberType();
890     result.decodePerAligned(new BitStreamReader(encodedBytes));
891     return result;
892   }
893 
encodePerUnaligned()894   @Override public Iterable<BitStream> encodePerUnaligned() {
895     return super.encodePerUnaligned();
896   }
897 
encodePerAligned()898   @Override public Iterable<BitStream> encodePerAligned() {
899     return super.encodePerAligned();
900   }
901 
decodePerUnaligned(BitStreamReader reader)902   @Override public void decodePerUnaligned(BitStreamReader reader) {
903     super.decodePerUnaligned(reader);
904   }
905 
decodePerAligned(BitStreamReader reader)906   @Override public void decodePerAligned(BitStreamReader reader) {
907     super.decodePerAligned(reader);
908   }
909 
toString()910   @Override public String toString() {
911     return toIndentedString("");
912   }
913 
toIndentedString(String indent)914   public String toIndentedString(String indent) {
915     return "gpsBitNumberType = " + getInteger() + ";\n";
916   }
917 }
918 
919 
920 /*
921  */
922 
923 
924 //
925 
926 /**
927  */
928 public static class codePhaseSearchWindowType extends Asn1Integer {
929   //
930 
931   private static final Asn1Tag TAG_codePhaseSearchWindowType
932       = Asn1Tag.fromClassAndNumber(-1, -1);
933 
codePhaseSearchWindowType()934   public codePhaseSearchWindowType() {
935     super();
936     setValueRange("0", "15");
937 
938   }
939 
940   @Override
941   @Nullable
getTag()942   protected Asn1Tag getTag() {
943     return TAG_codePhaseSearchWindowType;
944   }
945 
946   @Override
isTagImplicit()947   protected boolean isTagImplicit() {
948     return true;
949   }
950 
getPossibleFirstTags()951   public static Collection<Asn1Tag> getPossibleFirstTags() {
952     if (TAG_codePhaseSearchWindowType != null) {
953       return ImmutableList.of(TAG_codePhaseSearchWindowType);
954     } else {
955       return Asn1Integer.getPossibleFirstTags();
956     }
957   }
958 
959   /**
960    * Creates a new codePhaseSearchWindowType from encoded stream.
961    */
fromPerUnaligned(byte[] encodedBytes)962   public static codePhaseSearchWindowType fromPerUnaligned(byte[] encodedBytes) {
963     codePhaseSearchWindowType result = new codePhaseSearchWindowType();
964     result.decodePerUnaligned(new BitStreamReader(encodedBytes));
965     return result;
966   }
967 
968   /**
969    * Creates a new codePhaseSearchWindowType from encoded stream.
970    */
fromPerAligned(byte[] encodedBytes)971   public static codePhaseSearchWindowType fromPerAligned(byte[] encodedBytes) {
972     codePhaseSearchWindowType result = new codePhaseSearchWindowType();
973     result.decodePerAligned(new BitStreamReader(encodedBytes));
974     return result;
975   }
976 
encodePerUnaligned()977   @Override public Iterable<BitStream> encodePerUnaligned() {
978     return super.encodePerUnaligned();
979   }
980 
encodePerAligned()981   @Override public Iterable<BitStream> encodePerAligned() {
982     return super.encodePerAligned();
983   }
984 
decodePerUnaligned(BitStreamReader reader)985   @Override public void decodePerUnaligned(BitStreamReader reader) {
986     super.decodePerUnaligned(reader);
987   }
988 
decodePerAligned(BitStreamReader reader)989   @Override public void decodePerAligned(BitStreamReader reader) {
990     super.decodePerAligned(reader);
991   }
992 
toString()993   @Override public String toString() {
994     return toIndentedString("");
995   }
996 
toIndentedString(String indent)997   public String toIndentedString(String indent) {
998     return "codePhaseSearchWindowType = " + getInteger() + ";\n";
999   }
1000 }
1001 
1002 
1003 
1004 
1005 
1006 
1007 
encodePerUnaligned()1008   @Override public Iterable<BitStream> encodePerUnaligned() {
1009     return super.encodePerUnaligned();
1010   }
1011 
encodePerAligned()1012   @Override public Iterable<BitStream> encodePerAligned() {
1013     return super.encodePerAligned();
1014   }
1015 
decodePerUnaligned(BitStreamReader reader)1016   @Override public void decodePerUnaligned(BitStreamReader reader) {
1017     super.decodePerUnaligned(reader);
1018   }
1019 
decodePerAligned(BitStreamReader reader)1020   @Override public void decodePerAligned(BitStreamReader reader) {
1021     super.decodePerAligned(reader);
1022   }
1023 
toString()1024   @Override public String toString() {
1025     return toIndentedString("");
1026   }
1027 
toIndentedString(String indent)1028   public String toIndentedString(String indent) {
1029     StringBuilder builder = new StringBuilder();
1030     builder.append("AcquisElement = {\n");
1031     final String internalIndent = indent + "  ";
1032     for (SequenceComponent component : getComponents()) {
1033       if (component.isExplicitlySet()) {
1034         builder.append(internalIndent)
1035             .append(component.toIndentedString(internalIndent));
1036       }
1037     }
1038     if (isExtensible()) {
1039       builder.append(internalIndent).append("...\n");
1040       for (SequenceComponent component : getExtensionComponents()) {
1041         if (component.isExplicitlySet()) {
1042           builder.append(internalIndent)
1043               .append(component.toIndentedString(internalIndent));
1044         }
1045       }
1046     }
1047     builder.append(indent).append("};\n");
1048     return builder.toString();
1049   }
1050 }
1051