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.ulp_version_2_parameter_extensions; 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 ExtendedEphemeris extends Asn1Sequence { 41 // 42 43 private static final Asn1Tag TAG_ExtendedEphemeris 44 = Asn1Tag.fromClassAndNumber(-1, -1); 45 46 public ExtendedEphemeris() { 47 super(); 48 } 49 50 @Override 51 @Nullable 52 protected Asn1Tag getTag() { 53 return TAG_ExtendedEphemeris; 54 } 55 56 @Override 57 protected boolean isTagImplicit() { 58 return true; 59 } 60 61 public static Collection<Asn1Tag> getPossibleFirstTags() { 62 if (TAG_ExtendedEphemeris != null) { 63 return ImmutableList.of(TAG_ExtendedEphemeris); 64 } else { 65 return Asn1Sequence.getPossibleFirstTags(); 66 } 67 } 68 69 /** 70 * Creates a new ExtendedEphemeris from encoded stream. 71 */ 72 public static ExtendedEphemeris fromPerUnaligned(byte[] encodedBytes) { 73 ExtendedEphemeris result = new ExtendedEphemeris(); 74 result.decodePerUnaligned(new BitStreamReader(encodedBytes)); 75 return result; 76 } 77 78 /** 79 * Creates a new ExtendedEphemeris from encoded stream. 80 */ 81 public static ExtendedEphemeris fromPerAligned(byte[] encodedBytes) { 82 ExtendedEphemeris result = new ExtendedEphemeris(); 83 result.decodePerAligned(new BitStreamReader(encodedBytes)); 84 return result; 85 } 86 87 88 89 @Override protected boolean isExtensible() { 90 return true; 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 ExtendedEphemeris.validityType validity_; 102 public ExtendedEphemeris.validityType getValidity() { 103 return validity_; 104 } 105 /** 106 * @throws ClassCastException if value is not a ExtendedEphemeris.validityType 107 */ 108 public void setValidity(Asn1Object value) { 109 this.validity_ = (ExtendedEphemeris.validityType) value; 110 } 111 public ExtendedEphemeris.validityType setValidityToNewInstance() { 112 validity_ = new ExtendedEphemeris.validityType(); 113 return validity_; 114 } 115 116 117 118 119 120 121 @Override public Iterable<? extends SequenceComponent> getComponents() { 122 ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder(); 123 124 builder.add(new SequenceComponent() { 125 Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0); 126 127 @Override public boolean isExplicitlySet() { 128 return getValidity() != null; 129 } 130 131 @Override public boolean hasDefaultValue() { 132 return false; 133 } 134 135 @Override public boolean isOptional() { 136 return false; 137 } 138 139 @Override public Asn1Object getComponentValue() { 140 return getValidity(); 141 } 142 143 @Override public void setToNewInstance() { 144 setValidityToNewInstance(); 145 } 146 147 @Override public Collection<Asn1Tag> getPossibleFirstTags() { 148 return tag == null ? ExtendedEphemeris.validityType.getPossibleFirstTags() : ImmutableList.of(tag); 149 } 150 151 @Override 152 public Asn1Tag getTag() { 153 return tag; 154 } 155 156 @Override 157 public boolean isImplicitTagging() { 158 return true; 159 } 160 161 @Override public String toIndentedString(String indent) { 162 return "validity : " 163 + getValidity().toIndentedString(indent); 164 } 165 }); 166 167 return builder.build(); 168 } 169 170 @Override public Iterable<? extends SequenceComponent> 171 getExtensionComponents() { 172 ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder(); 173 174 return builder.build(); 175 } 176 177 178 /* 179 */ 180 181 182 // 183 184 /** 185 */ 186 public static class validityType extends Asn1Integer { 187 // 188 189 private static final Asn1Tag TAG_validityType 190 = Asn1Tag.fromClassAndNumber(-1, -1); 191 192 public validityType() { 193 super(); 194 setValueRange("1", "256"); 195 196 } 197 198 @Override 199 @Nullable 200 protected Asn1Tag getTag() { 201 return TAG_validityType; 202 } 203 204 @Override 205 protected boolean isTagImplicit() { 206 return true; 207 } 208 209 public static Collection<Asn1Tag> getPossibleFirstTags() { 210 if (TAG_validityType != null) { 211 return ImmutableList.of(TAG_validityType); 212 } else { 213 return Asn1Integer.getPossibleFirstTags(); 214 } 215 } 216 217 /** 218 * Creates a new validityType from encoded stream. 219 */ 220 public static validityType fromPerUnaligned(byte[] encodedBytes) { 221 validityType result = new validityType(); 222 result.decodePerUnaligned(new BitStreamReader(encodedBytes)); 223 return result; 224 } 225 226 /** 227 * Creates a new validityType from encoded stream. 228 */ 229 public static validityType fromPerAligned(byte[] encodedBytes) { 230 validityType result = new validityType(); 231 result.decodePerAligned(new BitStreamReader(encodedBytes)); 232 return result; 233 } 234 235 @Override public Iterable<BitStream> encodePerUnaligned() { 236 return super.encodePerUnaligned(); 237 } 238 239 @Override public Iterable<BitStream> encodePerAligned() { 240 return super.encodePerAligned(); 241 } 242 243 @Override public void decodePerUnaligned(BitStreamReader reader) { 244 super.decodePerUnaligned(reader); 245 } 246 247 @Override public void decodePerAligned(BitStreamReader reader) { 248 super.decodePerAligned(reader); 249 } 250 251 @Override public String toString() { 252 return toIndentedString(""); 253 } 254 255 public String toIndentedString(String indent) { 256 return "validityType = " + getInteger() + ";\n"; 257 } 258 } 259 260 261 262 263 264 @Override public Iterable<BitStream> encodePerUnaligned() { 265 return super.encodePerUnaligned(); 266 } 267 268 @Override public Iterable<BitStream> encodePerAligned() { 269 return super.encodePerAligned(); 270 } 271 272 @Override public void decodePerUnaligned(BitStreamReader reader) { 273 super.decodePerUnaligned(reader); 274 } 275 276 @Override public void decodePerAligned(BitStreamReader reader) { 277 super.decodePerAligned(reader); 278 } 279 280 @Override public String toString() { 281 return toIndentedString(""); 282 } 283 284 public String toIndentedString(String indent) { 285 StringBuilder builder = new StringBuilder(); 286 builder.append("ExtendedEphemeris = {\n"); 287 final String internalIndent = indent + " "; 288 for (SequenceComponent component : getComponents()) { 289 if (component.isExplicitlySet()) { 290 builder.append(internalIndent) 291 .append(component.toIndentedString(internalIndent)); 292 } 293 } 294 if (isExtensible()) { 295 builder.append(internalIndent).append("...\n"); 296 for (SequenceComponent component : getExtensionComponents()) { 297 if (component.isExplicitlySet()) { 298 builder.append(internalIndent) 299 .append(component.toIndentedString(internalIndent)); 300 } 301 } 302 } 303 builder.append(indent).append("};\n"); 304 return builder.toString(); 305 } 306 } 307